// Code generated from PostgreSQLParser.g4 by ANTLR 4.13.1. DO NOT EDIT.

package parser // PostgreSQLParser
import (
	"fmt"
	"strconv"
	"sync"

	"github.com/antlr4-go/antlr/v4"
)

// Suppress unused import errors
var _ = fmt.Printf
var _ = strconv.Itoa
var _ = sync.Once{}

type PostgreSQLParser struct {
	PostgreSQLParserBase
}

var PostgreSQLParserParserStaticData struct {
	once                   sync.Once
	serializedATN          []int32
	LiteralNames           []string
	SymbolicNames          []string
	RuleNames              []string
	PredictionContextCache *antlr.PredictionContextCache
	atn                    *antlr.ATN
	decisionToDFA          []*antlr.DFA
}

func postgresqlparserParserInit() {
	staticData := &PostgreSQLParserParserStaticData
	staticData.LiteralNames = []string{
		"", "'$'", "'('", "')'", "'['", "']'", "','", "';'", "':'", "'*'", "'='",
		"'.'", "'+'", "'-'", "'/'", "'^'", "'<'", "'>'", "'<<'", "'>>'", "':='",
		"'<='", "'=>'", "'>='", "'..'", "'<>'", "'::'", "'%'", "", "", "'ALL'",
		"'ANALYSE'", "'ANALYZE'", "'AND'", "'ANY'", "'ARRAY'", "'AS'", "'ASC'",
		"'ASYMMETRIC'", "'BOTH'", "'CASE'", "'CAST'", "'CHECK'", "'COLLATE'",
		"'COLUMN'", "'CONSTRAINT'", "'CREATE'", "'CURRENT_CATALOG'", "'CURRENT_DATE'",
		"'CURRENT_ROLE'", "'CURRENT_TIME'", "'CURRENT_TIMESTAMP'", "'CURRENT_USER'",
		"'DEFAULT'", "'DEFERRABLE'", "'DESC'", "'DISTINCT'", "'DO'", "'ELSE'",
		"'EXCEPT'", "'FALSE'", "'FETCH'", "'FOR'", "'FOREIGN'", "'FROM'", "'GRANT'",
		"'GROUP'", "'HAVING'", "'IN'", "'INITIALLY'", "'INTERSECT'", "'INTO'",
		"'LATERAL'", "'LEADING'", "'LIMIT'", "'LOCALTIME'", "'LOCALTIMESTAMP'",
		"'NOT'", "'NULL'", "'OFFSET'", "'ON'", "'ONLY'", "'OR'", "'ORDER'",
		"'PLACING'", "'PRIMARY'", "'REFERENCES'", "'RETURNING'", "'SELECT'",
		"'SESSION_USER'", "'SOME'", "'SYMMETRIC'", "'TABLE'", "'THEN'", "'TO'",
		"'TRAILING'", "'TRUE'", "'UNION'", "'UNIQUE'", "'USER'", "'USING'",
		"'VARIADIC'", "'WHEN'", "'WHERE'", "'WINDOW'", "'WITH'", "'AUTHORIZATION'",
		"'BINARY'", "'COLLATION'", "'CONCURRENTLY'", "'CROSS'", "'CURRENT_SCHEMA'",
		"'FREEZE'", "'FULL'", "'ILIKE'", "'INNER'", "'IS'", "'ISNULL'", "'JOIN'",
		"'LEFT'", "'LIKE'", "'NATURAL'", "'NOTNULL'", "'OUTER'", "'OVER'", "'OVERLAPS'",
		"'RIGHT'", "'SIMILAR'", "'VERBOSE'", "'ABORT'", "'ABSOLUTE'", "'ACCESS'",
		"'ACTION'", "'ADD'", "'ADMIN'", "'AFTER'", "'AGGREGATE'", "'ALSO'",
		"'ALTER'", "'ALWAYS'", "'ASSERTION'", "'ASSIGNMENT'", "'AT'", "'ATTRIBUTE'",
		"'BACKWARD'", "'BEFORE'", "'BEGIN'", "'BY'", "'CACHE'", "'CALLED'",
		"'CASCADE'", "'CASCADED'", "'CATALOG'", "'CHAIN'", "'CHARACTERISTICS'",
		"'CHECKPOINT'", "'CLASS'", "'CLOSE'", "'CLUSTER'", "'COMMENT'", "'COMMENTS'",
		"'COMMIT'", "'COMMITTED'", "'CONFIGURATION'", "'CONNECTION'", "'CONSTRAINTS'",
		"'CONTENT'", "'CONTINUE'", "'CONVERSION'", "'COPY'", "'COST'", "'CSV'",
		"'CURSOR'", "'CYCLE'", "'DATA'", "'DATABASE'", "'DAY'", "'DEALLOCATE'",
		"'DECLARE'", "'DEFAULTS'", "'DEFERRED'", "'DEFINER'", "'DELETE'", "'DELIMITER'",
		"'DELIMITERS'", "'DICTIONARY'", "'DISABLE'", "'DISCARD'", "'DOCUMENT'",
		"'DOMAIN'", "'DOUBLE'", "'DROP'", "'EACH'", "'ENABLE'", "'ENCODING'",
		"'ENCRYPTED'", "'ENUM'", "'ESCAPE'", "'EVENT'", "'EXCLUDE'", "'EXCLUDING'",
		"'EXCLUSIVE'", "'EXECUTE'", "'EXPLAIN'", "'EXTENSION'", "'EXTERNAL'",
		"'FAMILY'", "'FIRST'", "'FOLLOWING'", "'FORCE'", "'FORWARD'", "'FUNCTION'",
		"'FUNCTIONS'", "'GLOBAL'", "'GRANTED'", "'HANDLER'", "'HEADER'", "'HOLD'",
		"'HOUR'", "'IDENTITY'", "'IF'", "'IMMEDIATE'", "'IMMUTABLE'", "'IMPLICIT'",
		"'INCLUDING'", "'INCREMENT'", "'INDEX'", "'INDEXES'", "'INHERIT'", "'INHERITS'",
		"'INLINE'", "'INSENSITIVE'", "'INSERT'", "'INSTEAD'", "'INVOKER'", "'ISOLATION'",
		"'KEY'", "'LABEL'", "'LANGUAGE'", "'LARGE'", "'LAST'", "'LEAKPROOF'",
		"'LEVEL'", "'LISTEN'", "'LOAD'", "'LOCAL'", "'LOCATION'", "'LOCK'",
		"'MAPPING'", "'MATCH'", "'MATCHED'", "'MATERIALIZED'", "'MAXVALUE'",
		"'MERGE'", "'MINUTE'", "'MINVALUE'", "'MODE'", "'MONTH'", "'MOVE'",
		"'NAME'", "'NAMES'", "'NEXT'", "'NO'", "'NOTHING'", "'NOTIFY'", "'NOWAIT'",
		"'NULLS'", "'OBJECT'", "'OF'", "'OFF'", "'OIDS'", "'OPERATOR'", "'OPTION'",
		"'OPTIONS'", "'OWNED'", "'OWNER'", "'PARSER'", "'PARTIAL'", "'PARTITION'",
		"'PASSING'", "'PASSWORD'", "'PLANS'", "'PRECEDING'", "'PREPARE'", "'PREPARED'",
		"'PRESERVE'", "'PRIOR'", "'PRIVILEGES'", "'PROCEDURAL'", "'PROCEDURE'",
		"'PROGRAM'", "'QUOTE'", "'RANGE'", "'READ'", "'REASSIGN'", "'RECHECK'",
		"'RECURSIVE'", "'REF'", "'REFRESH'", "'REINDEX'", "'RELATIVE'", "'RELEASE'",
		"'RENAME'", "'REPEATABLE'", "'REPLACE'", "'REPLICA'", "'RESET'", "'RESTART'",
		"'RESTRICT'", "'RETURNS'", "'REVOKE'", "'ROLE'", "'ROLLBACK'", "'ROWS'",
		"'RULE'", "'SAVEPOINT'", "'SCHEMA'", "'SCROLL'", "'SEARCH'", "'SECOND'",
		"'SECURITY'", "'SEQUENCE'", "'SEQUENCES'", "'SERIALIZABLE'", "'SERVER'",
		"'SESSION'", "'SET'", "'SHARE'", "'SHOW'", "'SIMPLE'", "'SNAPSHOT'",
		"'STABLE'", "'STANDALONE'", "'START'", "'STATEMENT'", "'STATISTICS'",
		"'STDIN'", "'STDOUT'", "'STORAGE'", "'STRICT'", "'STRIP'", "'SYSID'",
		"'SYSTEM'", "'TABLES'", "'TABLESPACE'", "'TEMP'", "'TEMPLATE'", "'TEMPORARY'",
		"'TEXT'", "'TRANSACTION'", "'TRIGGER'", "'TRUNCATE'", "'TRUSTED'", "'TYPE'",
		"'TYPES'", "'UNBOUNDED'", "'UNCOMMITTED'", "'UNENCRYPTED'", "'UNKNOWN'",
		"'UNLISTEN'", "'UNLOGGED'", "'UNTIL'", "'UPDATE'", "'VACUUM'", "'VALID'",
		"'VALIDATE'", "'VALIDATOR'", "'VARYING'", "'VERSION'", "'VIEW'", "'VOLATILE'",
		"'WHITESPACE'", "'WITHOUT'", "'WORK'", "'WRAPPER'", "'WRITE'", "'XML'",
		"'YEAR'", "'YES'", "'ZONE'", "'BETWEEN'", "'BIGINT'", "'BIT'", "'BOOLEAN'",
		"'CHAR'", "'CHARACTER'", "'COALESCE'", "'DEC'", "'DECIMAL'", "'EXISTS'",
		"'EXTRACT'", "'FLOAT'", "'GREATEST'", "'INOUT'", "'INT'", "'INTEGER'",
		"'INTERVAL'", "'LEAST'", "'NATIONAL'", "'NCHAR'", "'NONE'", "'NULLIF'",
		"'NUMERIC'", "'OVERLAY'", "'POSITION'", "'PRECISION'", "'REAL'", "'ROW'",
		"'SETOF'", "'SMALLINT'", "'SUBSTRING'", "'TIME'", "'TIMESTAMP'", "'TREAT'",
		"'TRIM'", "'VALUES'", "'VARCHAR'", "'XMLATTRIBUTES'", "'XMLCOMMENT'",
		"'XMLAGG'", "'XML_IS_WELL_FORMED'", "'XML_IS_WELL_FORMED_DOCUMENT'",
		"'XML_IS_WELL_FORMED_CONTENT'", "'XPATH'", "'XPATH_EXISTS'", "'XMLCONCAT'",
		"'XMLELEMENT'", "'XMLEXISTS'", "'XMLFOREST'", "'XMLPARSE'", "'XMLPI'",
		"'XMLROOT'", "'XMLSERIALIZE'", "'CALL'", "'CURRENT'", "'ATTACH'", "'DETACH'",
		"'EXPRESSION'", "'GENERATED'", "'LOGGED'", "'STORED'", "'INCLUDE'",
		"'ROUTINE'", "'TRANSFORM'", "'IMPORT'", "'POLICY'", "'METHOD'", "'REFERENCING'",
		"'NEW'", "'OLD'", "'VALUE'", "'SUBSCRIPTION'", "'PUBLICATION'", "'OUT'",
		"'END'", "'ROUTINES'", "'SCHEMAS'", "'PROCEDURES'", "'INPUT'", "'SUPPORT'",
		"'PARALLEL'", "'SQL'", "'DEPENDS'", "'OVERRIDING'", "'CONFLICT'", "'SKIP'",
		"'LOCKED'", "'TIES'", "'ROLLUP'", "'CUBE'", "'GROUPING'", "'SETS'",
		"'TABLESAMPLE'", "'ORDINALITY'", "'XMLTABLE'", "'COLUMNS'", "'XMLNAMESPACES'",
		"'ROWTYPE'", "'NORMALIZED'", "'WITHIN'", "'FILTER'", "'GROUPS'", "'OTHERS'",
		"'NFC'", "'NFD'", "'NFKC'", "'NFKD'", "'UESCAPE'", "'VIEWS'", "'NORMALIZE'",
		"'DUMP'", "'PRINT_STRICT_PARAMS'", "'VARIABLE_CONFLICT'", "'ERROR'",
		"'USE_VARIABLE'", "'USE_COLUMN'", "'ALIAS'", "'CONSTANT'", "'PERFORM'",
		"'GET'", "'DIAGNOSTICS'", "'STACKED'", "'ELSIF'", "'WHILE'", "'REVERSE'",
		"'FOREACH'", "'SLICE'", "'EXIT'", "'RETURN'", "'QUERY'", "'RAISE'",
		"'SQLSTATE'", "'DEBUG'", "'LOG'", "'INFO'", "'NOTICE'", "'WARNING'",
		"'EXCEPTION'", "'ASSERT'", "'LOOP'", "'OPEN'", "'ABS'", "'CBRT'", "'CEIL'",
		"'CEILING'", "'DEGREES'", "'DIV'", "'EXP'", "'FACTORIAL'", "'FLOOR'",
		"'GCD'", "'LCM'", "'LN'", "'LOG10'", "'MIN_SCALE'", "'MOD'", "'PI'",
		"'POWER'", "'RADIANS'", "'ROUND'", "'SCALE'", "'SIGN'", "'SQRT'", "'TRIM_SCALE'",
		"'TRUNC'", "'WIDTH_BUCKET'", "'RANDOM'", "'SETSEED'", "'ACOS'", "'ACOSD'",
		"'ASIN'", "'ASIND'", "'ATAN'", "'ATAND'", "'ATAN2'", "'ATAN2D'", "'COS'",
		"'COSD'", "'COT'", "'COTD'", "'SIN'", "'SIND'", "'TAN'", "'TAND'", "'SINH'",
		"'COSH'", "'TANH'", "'ASINH'", "'ACOSH'", "'ATANH'", "'BIT_LENGTH'",
		"'CHAR_LENGTH'", "'CHARACTER_LENGTH'", "'LOWER'", "'OCTET_LENGTH'",
		"'UPPER'", "'ASCII'", "'BTRIM'", "'CHR'", "'CONCAT'", "'CONCAT_WS'",
		"'FORMAT'", "'INITCAP'", "'LENGTH'", "'LPAD'", "'LTRIM'", "'MD5'", "'PARSE_IDENT'",
		"'PG_CLIENT_ENCODING'", "'QUOTE_IDENT'", "'QUOTE_LITERAL'", "'QUOTE_NULLABLE'",
		"'REGEXP_COUNT'", "'REGEXP_INSTR'", "'REGEXP_LIKE'", "'REGEXP_MATCH'",
		"'REGEXP_MATCHES'", "'REGEXP_REPLACE'", "'REGEXP_SPLIT_TO_ARRAY'", "'REGEXP_SPLIT_TO_TABLE'",
		"'REGEXP_SUBSTR'", "'REPEAT'", "'RPAD'", "'RTRIM'", "'SPLIT_PART'",
		"'STARTS_WITH'", "'STRING_TO_ARRAY'", "'STRING_TO_TABLE'", "'STRPOS'",
		"'SUBSTR'", "'TO_ASCII'", "'TO_HEX'", "'TRANSLATE'", "'UNISTR'", "'AGE'",
		"'CLOCK_TIMESTAMP'", "'DATE_BIN'", "'DATE_PART'", "'DATE_TRUNC'", "'ISFINITE'",
		"'JUSTIFY_DAYS'", "'JUSTIFY_HOURS'", "'JUSTIFY_INTERVAL'", "'MAKE_DATE'",
		"'MAKE_INTERVAL'", "'MAKE_TIME'", "'MAKE_TIMESTAMP'", "'MAKE_TIMESTAMPTZ'",
		"'NOW'", "'STATEMENT_TIMESTAMP'", "'TIMEOFDAY'", "'TRANSACTION_TIMESTAMP'",
		"'TO_TIMESTAMP'", "'TO_CHAR'", "'TO_DATE'", "'TO_NUMBER'", "", "", "",
		"", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "",
		"", "", "", "", "", "", "", "", "", "", "", "", "", "'\\\\'", "", "",
		"", "", "", "", "", "", "", "'''",
	}
	staticData.SymbolicNames = []string{
		"", "Dollar", "OPEN_PAREN", "CLOSE_PAREN", "OPEN_BRACKET", "CLOSE_BRACKET",
		"COMMA", "SEMI", "COLON", "STAR", "EQUAL", "DOT", "PLUS", "MINUS", "SLASH",
		"CARET", "LT", "GT", "LESS_LESS", "GREATER_GREATER", "COLON_EQUALS",
		"LESS_EQUALS", "EQUALS_GREATER", "GREATER_EQUALS", "DOT_DOT", "NOT_EQUALS",
		"TYPECAST", "PERCENT", "PARAM", "Operator", "ALL", "ANALYSE", "ANALYZE",
		"AND", "ANY", "ARRAY", "AS", "ASC", "ASYMMETRIC", "BOTH", "CASE", "CAST",
		"CHECK", "COLLATE", "COLUMN", "CONSTRAINT", "CREATE", "CURRENT_CATALOG",
		"CURRENT_DATE", "CURRENT_ROLE", "CURRENT_TIME", "CURRENT_TIMESTAMP",
		"CURRENT_USER", "DEFAULT", "DEFERRABLE", "DESC", "DISTINCT", "DO", "ELSE",
		"EXCEPT", "FALSE_P", "FETCH", "FOR", "FOREIGN", "FROM", "GRANT", "GROUP_P",
		"HAVING", "IN_P", "INITIALLY", "INTERSECT", "INTO", "LATERAL_P", "LEADING",
		"LIMIT", "LOCALTIME", "LOCALTIMESTAMP", "NOT", "NULL_P", "OFFSET", "ON",
		"ONLY", "OR", "ORDER", "PLACING", "PRIMARY", "REFERENCES", "RETURNING",
		"SELECT", "SESSION_USER", "SOME", "SYMMETRIC", "TABLE", "THEN", "TO",
		"TRAILING", "TRUE_P", "UNION", "UNIQUE", "USER", "USING", "VARIADIC",
		"WHEN", "WHERE", "WINDOW", "WITH", "AUTHORIZATION", "BINARY", "COLLATION",
		"CONCURRENTLY", "CROSS", "CURRENT_SCHEMA", "FREEZE", "FULL", "ILIKE",
		"INNER_P", "IS", "ISNULL", "JOIN", "LEFT", "LIKE", "NATURAL", "NOTNULL",
		"OUTER_P", "OVER", "OVERLAPS", "RIGHT", "SIMILAR", "VERBOSE", "ABORT_P",
		"ABSOLUTE_P", "ACCESS", "ACTION", "ADD_P", "ADMIN", "AFTER", "AGGREGATE",
		"ALSO", "ALTER", "ALWAYS", "ASSERTION", "ASSIGNMENT", "AT", "ATTRIBUTE",
		"BACKWARD", "BEFORE", "BEGIN_P", "BY", "CACHE", "CALLED", "CASCADE",
		"CASCADED", "CATALOG", "CHAIN", "CHARACTERISTICS", "CHECKPOINT", "CLASS",
		"CLOSE", "CLUSTER", "COMMENT", "COMMENTS", "COMMIT", "COMMITTED", "CONFIGURATION",
		"CONNECTION", "CONSTRAINTS", "CONTENT_P", "CONTINUE_P", "CONVERSION_P",
		"COPY", "COST", "CSV", "CURSOR", "CYCLE", "DATA_P", "DATABASE", "DAY_P",
		"DEALLOCATE", "DECLARE", "DEFAULTS", "DEFERRED", "DEFINER", "DELETE_P",
		"DELIMITER", "DELIMITERS", "DICTIONARY", "DISABLE_P", "DISCARD", "DOCUMENT_P",
		"DOMAIN_P", "DOUBLE_P", "DROP", "EACH", "ENABLE_P", "ENCODING", "ENCRYPTED",
		"ENUM_P", "ESCAPE", "EVENT", "EXCLUDE", "EXCLUDING", "EXCLUSIVE", "EXECUTE",
		"EXPLAIN", "EXTENSION", "EXTERNAL", "FAMILY", "FIRST_P", "FOLLOWING",
		"FORCE", "FORWARD", "FUNCTION", "FUNCTIONS", "GLOBAL", "GRANTED", "HANDLER",
		"HEADER_P", "HOLD", "HOUR_P", "IDENTITY_P", "IF_P", "IMMEDIATE", "IMMUTABLE",
		"IMPLICIT_P", "INCLUDING", "INCREMENT", "INDEX", "INDEXES", "INHERIT",
		"INHERITS", "INLINE_P", "INSENSITIVE", "INSERT", "INSTEAD", "INVOKER",
		"ISOLATION", "KEY", "LABEL", "LANGUAGE", "LARGE_P", "LAST_P", "LEAKPROOF",
		"LEVEL", "LISTEN", "LOAD", "LOCAL", "LOCATION", "LOCK_P", "MAPPING",
		"MATCH", "MATCHED", "MATERIALIZED", "MAXVALUE", "MERGE", "MINUTE_P",
		"MINVALUE", "MODE", "MONTH_P", "MOVE", "NAME_P", "NAMES", "NEXT", "NO",
		"NOTHING", "NOTIFY", "NOWAIT", "NULLS_P", "OBJECT_P", "OF", "OFF", "OIDS",
		"OPERATOR", "OPTION", "OPTIONS", "OWNED", "OWNER", "PARSER", "PARTIAL",
		"PARTITION", "PASSING", "PASSWORD", "PLANS", "PRECEDING", "PREPARE",
		"PREPARED", "PRESERVE", "PRIOR", "PRIVILEGES", "PROCEDURAL", "PROCEDURE",
		"PROGRAM", "QUOTE", "RANGE", "READ", "REASSIGN", "RECHECK", "RECURSIVE",
		"REF", "REFRESH", "REINDEX", "RELATIVE_P", "RELEASE", "RENAME", "REPEATABLE",
		"REPLACE", "REPLICA", "RESET", "RESTART", "RESTRICT", "RETURNS", "REVOKE",
		"ROLE", "ROLLBACK", "ROWS", "RULE", "SAVEPOINT", "SCHEMA", "SCROLL",
		"SEARCH", "SECOND_P", "SECURITY", "SEQUENCE", "SEQUENCES", "SERIALIZABLE",
		"SERVER", "SESSION", "SET", "SHARE", "SHOW", "SIMPLE", "SNAPSHOT", "STABLE",
		"STANDALONE_P", "START", "STATEMENT", "STATISTICS", "STDIN", "STDOUT",
		"STORAGE", "STRICT_P", "STRIP_P", "SYSID", "SYSTEM_P", "TABLES", "TABLESPACE",
		"TEMP", "TEMPLATE", "TEMPORARY", "TEXT_P", "TRANSACTION", "TRIGGER",
		"TRUNCATE", "TRUSTED", "TYPE_P", "TYPES_P", "UNBOUNDED", "UNCOMMITTED",
		"UNENCRYPTED", "UNKNOWN", "UNLISTEN", "UNLOGGED", "UNTIL", "UPDATE",
		"VACUUM", "VALID", "VALIDATE", "VALIDATOR", "VARYING", "VERSION_P",
		"VIEW", "VOLATILE", "WHITESPACE_P", "WITHOUT", "WORK", "WRAPPER", "WRITE",
		"XML_P", "YEAR_P", "YES_P", "ZONE", "BETWEEN", "BIGINT", "BIT", "BOOLEAN_P",
		"CHAR_P", "CHARACTER", "COALESCE", "DEC", "DECIMAL_P", "EXISTS", "EXTRACT",
		"FLOAT_P", "GREATEST", "INOUT", "INT_P", "INTEGER", "INTERVAL", "LEAST",
		"NATIONAL", "NCHAR", "NONE", "NULLIF", "NUMERIC", "OVERLAY", "POSITION",
		"PRECISION", "REAL", "ROW", "SETOF", "SMALLINT", "SUBSTRING", "TIME",
		"TIMESTAMP", "TREAT", "TRIM", "VALUES", "VARCHAR", "XMLATTRIBUTES",
		"XMLCOMMENT", "XMLAGG", "XML_IS_WELL_FORMED", "XML_IS_WELL_FORMED_DOCUMENT",
		"XML_IS_WELL_FORMED_CONTENT", "XPATH", "XPATH_EXISTS", "XMLCONCAT",
		"XMLELEMENT", "XMLEXISTS", "XMLFOREST", "XMLPARSE", "XMLPI", "XMLROOT",
		"XMLSERIALIZE", "CALL", "CURRENT_P", "ATTACH", "DETACH", "EXPRESSION",
		"GENERATED", "LOGGED", "STORED", "INCLUDE", "ROUTINE", "TRANSFORM",
		"IMPORT_P", "POLICY", "METHOD", "REFERENCING", "NEW", "OLD", "VALUE_P",
		"SUBSCRIPTION", "PUBLICATION", "OUT_P", "END_P", "ROUTINES", "SCHEMAS",
		"PROCEDURES", "INPUT_P", "SUPPORT", "PARALLEL", "SQL_P", "DEPENDS",
		"OVERRIDING", "CONFLICT", "SKIP_P", "LOCKED", "TIES", "ROLLUP", "CUBE",
		"GROUPING", "SETS", "TABLESAMPLE", "ORDINALITY", "XMLTABLE", "COLUMNS",
		"XMLNAMESPACES", "ROWTYPE", "NORMALIZED", "WITHIN", "FILTER", "GROUPS",
		"OTHERS", "NFC", "NFD", "NFKC", "NFKD", "UESCAPE", "VIEWS", "NORMALIZE",
		"DUMP", "PRINT_STRICT_PARAMS", "VARIABLE_CONFLICT", "ERROR", "USE_VARIABLE",
		"USE_COLUMN", "ALIAS", "CONSTANT", "PERFORM", "GET", "DIAGNOSTICS",
		"STACKED", "ELSIF", "WHILE", "REVERSE", "FOREACH", "SLICE", "EXIT",
		"RETURN", "QUERY", "RAISE", "SQLSTATE", "DEBUG", "LOG", "INFO", "NOTICE",
		"WARNING", "EXCEPTION", "ASSERT", "LOOP", "OPEN", "ABS", "CBRT", "CEIL",
		"CEILING", "DEGREES", "DIV", "EXP", "FACTORIAL", "FLOOR", "GCD", "LCM",
		"LN", "LOG10", "MIN_SCALE", "MOD", "PI", "POWER", "RADIANS", "ROUND",
		"SCALE", "SIGN", "SQRT", "TRIM_SCALE", "TRUNC", "WIDTH_BUCKET", "RANDOM",
		"SETSEED", "ACOS", "ACOSD", "ASIN", "ASIND", "ATAN", "ATAND", "ATAN2",
		"ATAN2D", "COS", "COSD", "COT", "COTD", "SIN", "SIND", "TAN", "TAND",
		"SINH", "COSH", "TANH", "ASINH", "ACOSH", "ATANH", "BIT_LENGTH", "CHAR_LENGTH",
		"CHARACTER_LENGTH", "LOWER", "OCTET_LENGTH", "UPPER", "ASCII", "BTRIM",
		"CHR", "CONCAT", "CONCAT_WS", "FORMAT", "INITCAP", "LENGTH", "LPAD",
		"LTRIM", "MD5", "PARSE_IDENT", "PG_CLIENT_ENCODING", "QUOTE_IDENT",
		"QUOTE_LITERAL", "QUOTE_NULLABLE", "REGEXP_COUNT", "REGEXP_INSTR", "REGEXP_LIKE",
		"REGEXP_MATCH", "REGEXP_MATCHES", "REGEXP_REPLACE", "REGEXP_SPLIT_TO_ARRAY",
		"REGEXP_SPLIT_TO_TABLE", "REGEXP_SUBSTR", "REPEAT", "RPAD", "RTRIM",
		"SPLIT_PART", "STARTS_WITH", "STRING_TO_ARRAY", "STRING_TO_TABLE", "STRPOS",
		"SUBSTR", "TO_ASCII", "TO_HEX", "TRANSLATE", "UNISTR", "AGE", "CLOCK_TIMESTAMP",
		"DATE_BIN", "DATE_PART", "DATE_TRUNC", "ISFINITE", "JUSTIFY_DAYS", "JUSTIFY_HOURS",
		"JUSTIFY_INTERVAL", "MAKE_DATE", "MAKE_INTERVAL", "MAKE_TIME", "MAKE_TIMESTAMP",
		"MAKE_TIMESTAMPTZ", "NOW", "STATEMENT_TIMESTAMP", "TIMEOFDAY", "TRANSACTION_TIMESTAMP",
		"TO_TIMESTAMP", "TO_CHAR", "TO_DATE", "TO_NUMBER", "Identifier", "QuotedIdentifier",
		"UnterminatedQuotedIdentifier", "InvalidQuotedIdentifier", "InvalidUnterminatedQuotedIdentifier",
		"UnicodeQuotedIdentifier", "UnterminatedUnicodeQuotedIdentifier", "InvalidUnicodeQuotedIdentifier",
		"InvalidUnterminatedUnicodeQuotedIdentifier", "StringConstant", "UnterminatedStringConstant",
		"UnicodeEscapeStringConstant", "UnterminatedUnicodeEscapeStringConstant",
		"BeginDollarStringConstant", "BinaryStringConstant", "UnterminatedBinaryStringConstant",
		"InvalidBinaryStringConstant", "InvalidUnterminatedBinaryStringConstant",
		"HexadecimalStringConstant", "UnterminatedHexadecimalStringConstant",
		"InvalidHexadecimalStringConstant", "InvalidUnterminatedHexadecimalStringConstant",
		"Integral", "NumericFail", "Numeric", "PLSQLVARIABLENAME", "PLSQLIDENTIFIER",
		"Whitespace", "Newline", "LineComment", "BlockComment", "UnterminatedBlockComment",
		"MetaCommand", "EndMetaCommand", "ErrorCharacter", "EscapeStringConstant",
		"UnterminatedEscapeStringConstant", "InvalidEscapeStringConstant", "InvalidUnterminatedEscapeStringConstant",
		"AfterEscapeStringConstantMode_NotContinued", "AfterEscapeStringConstantWithNewlineMode_NotContinued",
		"DollarText", "EndDollarStringConstant", "AfterEscapeStringConstantWithNewlineMode_Continued",
	}
	staticData.RuleNames = []string{
		"root", "plsqlroot", "stmtblock", "stmtmulti", "stmt", "plsqlconsolecommand",
		"callstmt", "createrolestmt", "opt_with", "optrolelist", "alteroptrolelist",
		"alteroptroleelem", "createoptroleelem", "createuserstmt", "alterrolestmt",
		"opt_in_database", "alterrolesetstmt", "droprolestmt", "creategroupstmt",
		"altergroupstmt", "add_drop", "createschemastmt", "optschemaname", "optschemaeltlist",
		"schema_stmt", "variablesetstmt", "set_rest", "generic_set", "set_rest_more",
		"var_name", "var_list", "var_value", "iso_level", "opt_boolean_or_string",
		"zone_value", "opt_encoding", "nonreservedword_or_sconst", "variableresetstmt",
		"reset_rest", "generic_reset", "setresetclause", "functionsetresetclause",
		"variableshowstmt", "constraintssetstmt", "constraints_set_list", "constraints_set_mode",
		"checkpointstmt", "discardstmt", "altertablestmt", "alter_table_cmds",
		"partition_cmd", "index_partition_cmd", "alter_table_cmd", "alter_column_default",
		"opt_drop_behavior", "opt_collate_clause", "alter_using", "replica_identity",
		"reloptions", "opt_reloptions", "reloption_list", "reloption_elem",
		"alter_identity_column_option_list", "alter_identity_column_option",
		"partitionboundspec", "hash_partbound_elem", "hash_partbound", "altercompositetypestmt",
		"alter_type_cmds", "alter_type_cmd", "closeportalstmt", "copystmt",
		"copy_from", "opt_program", "copy_file_name", "copy_options", "copy_opt_list",
		"copy_opt_item", "opt_binary", "copy_delimiter", "opt_using", "copy_generic_opt_list",
		"copy_generic_opt_elem", "copy_generic_opt_arg", "copy_generic_opt_arg_list",
		"copy_generic_opt_arg_list_item", "createstmt", "opttemp", "opttableelementlist",
		"opttypedtableelementlist", "tableelementlist", "typedtableelementlist",
		"tableelement", "typedtableelement", "columnDef", "columnOptions", "colquallist",
		"colconstraint", "colconstraintelem", "generated_when", "constraintattr",
		"tablelikeclause", "tablelikeoptionlist", "tablelikeoption", "tableconstraint",
		"constraintelem", "opt_no_inherit", "opt_column_list", "columnlist",
		"columnElem", "opt_c_include", "key_match", "exclusionconstraintlist",
		"exclusionconstraintelem", "exclusionwhereclause", "key_actions", "key_update",
		"key_delete", "key_action", "optinherit", "optpartitionspec", "partitionspec",
		"part_params", "part_elem", "table_access_method_clause", "optwith",
		"oncommitoption", "opttablespace", "optconstablespace", "existingindex",
		"createstatsstmt", "alterstatsstmt", "createasstmt", "create_as_target",
		"opt_with_data", "creatematviewstmt", "create_mv_target", "optnolog",
		"refreshmatviewstmt", "createseqstmt", "alterseqstmt", "optseqoptlist",
		"optparenthesizedseqoptlist", "seqoptlist", "seqoptelem", "opt_by",
		"numericonly", "numericonly_list", "createplangstmt", "opt_trusted",
		"handler_name", "opt_inline_handler", "validator_clause", "opt_validator",
		"opt_procedural", "createtablespacestmt", "opttablespaceowner", "droptablespacestmt",
		"createextensionstmt", "create_extension_opt_list", "create_extension_opt_item",
		"alterextensionstmt", "alter_extension_opt_list", "alter_extension_opt_item",
		"alterextensioncontentsstmt", "createfdwstmt", "fdw_option", "fdw_options",
		"opt_fdw_options", "alterfdwstmt", "create_generic_options", "generic_option_list",
		"alter_generic_options", "alter_generic_option_list", "alter_generic_option_elem",
		"generic_option_elem", "generic_option_name", "generic_option_arg",
		"createforeignserverstmt", "opt_type", "foreign_server_version", "opt_foreign_server_version",
		"alterforeignserverstmt", "createforeigntablestmt", "importforeignschemastmt",
		"import_qualification_type", "import_qualification", "createusermappingstmt",
		"auth_ident", "dropusermappingstmt", "alterusermappingstmt", "createpolicystmt",
		"alterpolicystmt", "rowsecurityoptionalexpr", "rowsecurityoptionalwithcheck",
		"rowsecuritydefaulttorole", "rowsecurityoptionaltorole", "rowsecuritydefaultpermissive",
		"rowsecuritydefaultforcmd", "row_security_cmd", "createamstmt", "am_type",
		"createtrigstmt", "triggeractiontime", "triggerevents", "triggeroneevent",
		"triggerreferencing", "triggertransitions", "triggertransition", "transitionoldornew",
		"transitionrowortable", "transitionrelname", "triggerforspec", "triggerforopteach",
		"triggerfortype", "triggerwhen", "function_or_procedure", "triggerfuncargs",
		"triggerfuncarg", "optconstrfromtable", "constraintattributespec", "constraintattributeElem",
		"createeventtrigstmt", "event_trigger_when_list", "event_trigger_when_item",
		"event_trigger_value_list", "altereventtrigstmt", "enable_trigger",
		"createassertionstmt", "definestmt", "definition", "def_list", "def_elem",
		"def_arg", "old_aggr_definition", "old_aggr_list", "old_aggr_elem",
		"opt_enum_val_list", "enum_val_list", "alterenumstmt", "opt_if_not_exists",
		"createopclassstmt", "opclass_item_list", "opclass_item", "opt_default",
		"opt_opfamily", "opclass_purpose", "opt_recheck", "createopfamilystmt",
		"alteropfamilystmt", "opclass_drop_list", "opclass_drop", "dropopclassstmt",
		"dropopfamilystmt", "dropownedstmt", "reassignownedstmt", "dropstmt",
		"object_type_any_name", "object_type_name", "drop_type_name", "object_type_name_on_any_name",
		"any_name_list", "any_name", "attrs", "type_name_list", "truncatestmt",
		"opt_restart_seqs", "commentstmt", "comment_text", "seclabelstmt", "opt_provider",
		"security_label", "fetchstmt", "fetch_args", "from_in", "opt_from_in",
		"grantstmt", "revokestmt", "privileges", "privilege_list", "privilege",
		"privilege_target", "grantee_list", "grantee", "opt_grant_grant_option",
		"grantrolestmt", "revokerolestmt", "opt_grant_admin_option", "opt_granted_by",
		"alterdefaultprivilegesstmt", "defacloptionlist", "defacloption", "defaclaction",
		"defacl_privilege_target", "indexstmt", "opt_unique", "opt_concurrently",
		"opt_index_name", "access_method_clause", "index_params", "index_elem_options",
		"index_elem", "opt_include", "index_including_params", "opt_collate",
		"opt_class", "opt_asc_desc", "opt_nulls_order", "createfunctionstmt",
		"opt_or_replace", "func_args", "func_args_list", "function_with_argtypes_list",
		"function_with_argtypes", "func_args_with_defaults", "func_args_with_defaults_list",
		"func_arg", "arg_class", "param_name", "func_return", "func_type", "func_arg_with_default",
		"aggr_arg", "aggr_args", "aggr_args_list", "aggregate_with_argtypes",
		"aggregate_with_argtypes_list", "createfunc_opt_list", "common_func_opt_item",
		"createfunc_opt_item", "func_as", "transform_type_list", "opt_definition",
		"table_func_column", "table_func_column_list", "alterfunctionstmt",
		"alterfunc_opt_list", "opt_restrict", "removefuncstmt", "removeaggrstmt",
		"removeoperstmt", "oper_argtypes", "any_operator", "operator_with_argtypes_list",
		"operator_with_argtypes", "dostmt", "dostmt_opt_list", "dostmt_opt_item",
		"createcaststmt", "cast_context", "dropcaststmt", "opt_if_exists", "createtransformstmt",
		"transform_element_list", "droptransformstmt", "reindexstmt", "reindex_target_type",
		"reindex_target_multitable", "reindex_option_list", "reindex_option_elem",
		"altertblspcstmt", "renamestmt", "opt_column", "opt_set_data", "alterobjectdependsstmt",
		"opt_no", "alterobjectschemastmt", "alteroperatorstmt", "operator_def_list",
		"operator_def_elem", "operator_def_arg", "altertypestmt", "alterownerstmt",
		"createpublicationstmt", "opt_publication_for_tables", "publication_for_tables",
		"alterpublicationstmt", "createsubscriptionstmt", "publication_name_list",
		"publication_name_item", "altersubscriptionstmt", "dropsubscriptionstmt",
		"rulestmt", "ruleactionlist", "ruleactionmulti", "ruleactionstmt", "ruleactionstmtOrEmpty",
		"event", "opt_instead", "notifystmt", "notify_payload", "listenstmt",
		"unlistenstmt", "transactionstmt", "opt_transaction", "transaction_mode_item",
		"transaction_mode_list", "transaction_mode_list_or_empty", "opt_transaction_chain",
		"viewstmt", "opt_check_option", "loadstmt", "createdbstmt", "createdb_opt_list",
		"createdb_opt_items", "createdb_opt_item", "createdb_opt_name", "opt_equal",
		"alterdatabasestmt", "alterdatabasesetstmt", "dropdbstmt", "drop_option_list",
		"drop_option", "altercollationstmt", "altersystemstmt", "createdomainstmt",
		"alterdomainstmt", "opt_as", "altertsdictionarystmt", "altertsconfigurationstmt",
		"any_with", "createconversionstmt", "clusterstmt", "cluster_index_specification",
		"vacuumstmt", "analyzestmt", "vac_analyze_option_list", "analyze_keyword",
		"vac_analyze_option_elem", "vac_analyze_option_name", "vac_analyze_option_arg",
		"opt_analyze", "opt_verbose", "opt_full", "opt_freeze", "opt_name_list",
		"vacuum_relation", "vacuum_relation_list", "opt_vacuum_relation_list",
		"explainstmt", "explainablestmt", "explain_option_list", "explain_option_elem",
		"explain_option_name", "explain_option_arg", "preparestmt", "prep_type_clause",
		"preparablestmt", "executestmt", "execute_param_clause", "deallocatestmt",
		"insertstmt", "insert_target", "insert_rest", "override_kind", "insert_column_list",
		"insert_column_item", "opt_on_conflict", "opt_conf_expr", "returning_clause",
		"mergestmt", "merge_insert_clause", "merge_update_clause", "merge_delete_clause",
		"deletestmt", "using_clause", "lockstmt", "opt_lock", "lock_type", "opt_nowait",
		"opt_nowait_or_skip", "updatestmt", "set_clause_list", "set_clause",
		"set_target", "set_target_list", "declarecursorstmt", "cursor_name",
		"cursor_options", "opt_hold", "selectstmt", "select_with_parens", "select_no_parens",
		"select_clause", "simple_select_intersect", "simple_select_pramary",
		"with_clause", "cte_list", "common_table_expr", "opt_materialized",
		"opt_with_clause", "into_clause", "opt_strict", "opttempTableName",
		"opt_table", "all_or_distinct", "distinct_clause", "opt_all_clause",
		"opt_sort_clause", "sort_clause", "sortby_list", "sortby", "select_limit",
		"opt_select_limit", "limit_clause", "offset_clause", "select_limit_value",
		"select_offset_value", "select_fetch_first_value", "i_or_f_const", "row_or_rows",
		"first_or_next", "group_clause", "group_by_list", "group_by_item", "empty_grouping_set",
		"rollup_clause", "cube_clause", "grouping_sets_clause", "having_clause",
		"for_locking_clause", "opt_for_locking_clause", "for_locking_items",
		"for_locking_item", "for_locking_strength", "locked_rels_list", "values_clause",
		"from_clause", "from_list", "non_ansi_join", "table_ref", "alias_clause",
		"opt_alias_clause", "table_alias_clause", "func_alias_clause", "join_type",
		"join_qual", "relation_expr", "relation_expr_list", "relation_expr_opt_alias",
		"tablesample_clause", "opt_repeatable_clause", "func_table", "rowsfrom_item",
		"rowsfrom_list", "opt_col_def_list", "opt_ordinality", "where_clause",
		"where_or_current_clause", "opttablefuncelementlist", "tablefuncelementlist",
		"tablefuncelement", "xmltable", "xmltable_column_list", "xmltable_column_el",
		"xmltable_column_option_list", "xmltable_column_option_el", "xml_namespace_list",
		"xml_namespace_el", "typename", "opt_array_bounds", "simpletypename",
		"consttypename", "generictype", "opt_type_modifiers", "numeric", "opt_float",
		"bit", "constbit", "bitwithlength", "bitwithoutlength", "character",
		"constcharacter", "character_c", "opt_varying", "constdatetime", "constinterval",
		"opt_timezone", "opt_interval", "interval_second", "opt_escape", "a_expr",
		"a_expr_qual", "a_expr_lessless", "a_expr_or", "a_expr_and", "a_expr_between",
		"a_expr_in", "a_expr_unary_not", "a_expr_isnull", "a_expr_is_not", "a_expr_compare",
		"a_expr_like", "a_expr_qual_op", "a_expr_unary_qualop", "a_expr_add",
		"a_expr_mul", "a_expr_caret", "a_expr_unary_sign", "a_expr_at_time_zone",
		"a_expr_collate", "a_expr_typecast", "b_expr", "c_expr", "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", "func_arg_list",
		"func_arg_expr", "type_list", "array_expr", "array_expr_list", "extract_list",
		"extract_arg", "unicode_normal_form", "overlay_list", "position_list",
		"substr_list", "trim_list", "in_expr", "case_expr", "when_clause_list",
		"when_clause", "case_default", "case_arg", "columnref", "indirection_el",
		"opt_slice_bound", "indirection", "opt_indirection", "opt_target_list",
		"target_list", "target_el", "qualified_name_list", "qualified_name",
		"name_list", "name", "attr_name", "file_name", "func_name", "aexprconst",
		"xconst", "bconst", "fconst", "iconst", "sconst", "anysconst", "opt_uescape",
		"signediconst", "roleid", "rolespec", "role_list", "colid", "table_alias",
		"type_function_name", "nonreservedword", "collabel", "identifier", "plsqlidentifier",
		"unreserved_keyword", "col_name_keyword", "type_func_name_keyword",
		"reserved_keyword", "builtin_function_name", "pl_function", "comp_options",
		"comp_option", "sharp", "option_value", "opt_semi", "pl_block", "decl_sect",
		"decl_start", "decl_stmts", "label_decl", "decl_stmt", "decl_statement",
		"opt_scrollable", "decl_cursor_query", "decl_cursor_args", "decl_cursor_arglist",
		"decl_cursor_arg", "decl_is_for", "decl_aliasitem", "decl_varname",
		"decl_const", "decl_datatype", "decl_collate", "decl_notnull", "decl_defval",
		"decl_defkey", "assign_operator", "proc_sect", "proc_stmt", "stmt_perform",
		"stmt_call", "opt_expr_list", "stmt_assign", "stmt_getdiag", "getdiag_area_opt",
		"getdiag_list", "getdiag_list_item", "getdiag_item", "getdiag_target",
		"assign_var", "stmt_if", "stmt_elsifs", "stmt_else", "stmt_case", "opt_expr_until_when",
		"case_when_list", "case_when", "opt_case_else", "stmt_loop", "stmt_while",
		"stmt_for", "for_control", "opt_for_using_expression", "opt_cursor_parameters",
		"opt_reverse", "opt_by_expression", "for_variable", "stmt_foreach_a",
		"foreach_slice", "stmt_exit", "exit_type", "stmt_return", "opt_return_result",
		"stmt_raise", "opt_stmt_raise_level", "opt_raise_list", "opt_raise_using",
		"opt_raise_using_elem", "opt_raise_using_elem_list", "stmt_assert",
		"opt_stmt_assert_message", "loop_body", "stmt_execsql", "stmt_dynexecute",
		"opt_execute_using", "opt_execute_using_list", "opt_execute_into", "stmt_open",
		"opt_open_bound_list_item", "opt_open_bound_list", "opt_open_using",
		"opt_scroll_option", "opt_scroll_option_no", "stmt_fetch", "into_target",
		"opt_cursor_from", "opt_fetch_direction", "stmt_move", "stmt_close",
		"stmt_null", "stmt_commit", "stmt_rollback", "plsql_opt_transaction_chain",
		"stmt_set", "cursor_variable", "exception_sect", "proc_exceptions",
		"proc_exception", "proc_conditions", "proc_condition", "opt_block_label",
		"opt_loop_label", "opt_label", "opt_exitcond", "any_identifier", "plsql_unreserved_keyword",
		"sql_expression", "expr_until_then", "expr_until_semi", "expr_until_rightbracket",
		"expr_until_loop", "make_execsql_stmt", "opt_returning_clause_into",
	}
	staticData.PredictionContextCache = antlr.NewPredictionContextCache()
	staticData.serializedATN = []int32{
		4, 1, 679, 10695, 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, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 1, 2, 1, 2, 1, 3, 1,
		3, 3, 3, 1634, 8, 3, 5, 3, 1636, 8, 3, 10, 3, 12, 3, 1639, 9, 3, 1, 4,
		1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4,
		1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4,
		1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4,
		1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4,
		1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4,
		1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4,
		1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4,
		1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4,
		1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4,
		1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4,
		1, 4, 1, 4, 1, 4, 1, 4, 3, 4, 1766, 8, 4, 1, 5, 1, 5, 3, 5, 1770, 8, 5,
		1, 6, 1, 6, 1, 6, 1, 7, 1, 7, 1, 7, 1, 7, 1, 7, 1, 7, 1, 8, 1, 8, 3, 8,
		1783, 8, 8, 1, 9, 5, 9, 1786, 8, 9, 10, 9, 12, 9, 1789, 9, 9, 1, 10, 5,
		10, 1792, 8, 10, 10, 10, 12, 10, 1795, 9, 10, 1, 11, 1, 11, 1, 11, 3, 11,
		1800, 8, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1,
		11, 1, 11, 1, 11, 1, 11, 1, 11, 3, 11, 1815, 8, 11, 1, 12, 1, 12, 1, 12,
		1, 12, 1, 12, 1, 12, 1, 12, 1, 12, 1, 12, 1, 12, 3, 12, 1827, 8, 12, 1,
		13, 1, 13, 1, 13, 1, 13, 1, 13, 1, 13, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14,
		1, 14, 1, 15, 1, 15, 1, 15, 1, 15, 3, 15, 1845, 8, 15, 1, 16, 1, 16, 1,
		16, 3, 16, 1850, 8, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 17, 1, 17, 1, 17,
		1, 17, 3, 17, 1860, 8, 17, 1, 17, 1, 17, 1, 18, 1, 18, 1, 18, 1, 18, 1,
		18, 1, 18, 1, 19, 1, 19, 1, 19, 1, 19, 1, 19, 1, 19, 1, 19, 1, 20, 1, 20,
		1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 3, 21, 1884, 8, 21, 1, 21, 1, 21, 1,
		21, 1, 21, 1, 21, 3, 21, 1891, 8, 21, 1, 21, 1, 21, 1, 22, 1, 22, 3, 22,
		1897, 8, 22, 1, 23, 5, 23, 1900, 8, 23, 10, 23, 12, 23, 1903, 9, 23, 1,
		24, 1, 24, 1, 24, 1, 24, 1, 24, 1, 24, 3, 24, 1911, 8, 24, 1, 25, 1, 25,
		3, 25, 1915, 8, 25, 1, 25, 1, 25, 1, 26, 1, 26, 1, 26, 1, 26, 1, 26, 1,
		26, 1, 26, 1, 26, 3, 26, 1927, 8, 26, 1, 27, 1, 27, 1, 27, 1, 27, 1, 28,
		1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1,
		28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28,
		1, 28, 1, 28, 1, 28, 3, 28, 1958, 8, 28, 1, 29, 1, 29, 1, 29, 5, 29, 1963,
		8, 29, 10, 29, 12, 29, 1966, 9, 29, 1, 30, 1, 30, 1, 30, 5, 30, 1971, 8,
		30, 10, 30, 12, 30, 1974, 9, 30, 1, 31, 1, 31, 3, 31, 1978, 8, 31, 1, 32,
		1, 32, 1, 32, 1, 32, 1, 32, 3, 32, 1985, 8, 32, 1, 33, 1, 33, 1, 33, 1,
		33, 3, 33, 1991, 8, 33, 1, 34, 1, 34, 1, 34, 1, 34, 1, 34, 1, 34, 1, 34,
		1, 34, 1, 34, 1, 34, 1, 34, 1, 34, 1, 34, 1, 34, 1, 34, 3, 34, 2008, 8,
		34, 1, 35, 1, 35, 1, 35, 3, 35, 2013, 8, 35, 1, 36, 1, 36, 3, 36, 2017,
		8, 36, 1, 37, 1, 37, 1, 37, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1,
		38, 1, 38, 3, 38, 2030, 8, 38, 1, 39, 1, 39, 3, 39, 2034, 8, 39, 1, 40,
		1, 40, 1, 40, 3, 40, 2039, 8, 40, 1, 41, 1, 41, 1, 41, 3, 41, 2044, 8,
		41, 1, 42, 1, 42, 1, 42, 1, 42, 1, 42, 1, 42, 1, 42, 1, 42, 1, 42, 1, 42,
		3, 42, 2056, 8, 42, 1, 43, 1, 43, 1, 43, 1, 43, 1, 43, 1, 44, 1, 44, 3,
		44, 2065, 8, 44, 1, 45, 1, 45, 1, 46, 1, 46, 1, 47, 1, 47, 1, 47, 1, 48,
		1, 48, 1, 48, 1, 48, 3, 48, 2078, 8, 48, 1, 48, 1, 48, 1, 48, 3, 48, 2083,
		8, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 3,
		48, 2094, 8, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48,
		1, 48, 3, 48, 2105, 8, 48, 1, 48, 1, 48, 1, 48, 3, 48, 2110, 8, 48, 1,
		48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 3, 48, 2121,
		8, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 3,
		48, 2132, 8, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 3, 48,
		2141, 8, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 3,
		48, 2151, 8, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48,
		1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 3, 48, 2166, 8, 48, 1, 48, 1, 48, 1,
		48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 3, 48, 2178, 8, 48,
		1, 48, 1, 48, 1, 48, 3, 48, 2183, 8, 48, 1, 49, 1, 49, 1, 49, 5, 49, 2188,
		8, 49, 10, 49, 12, 49, 2191, 9, 49, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50,
		1, 50, 1, 50, 1, 50, 3, 50, 2201, 8, 50, 1, 51, 1, 51, 1, 51, 1, 51, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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,
		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, 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, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 3,
		52, 2459, 8, 52, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 3, 53, 2466, 8, 53,
		1, 54, 1, 54, 1, 54, 3, 54, 2471, 8, 54, 1, 55, 1, 55, 1, 55, 3, 55, 2476,
		8, 55, 1, 56, 1, 56, 1, 56, 3, 56, 2481, 8, 56, 1, 57, 1, 57, 1, 57, 1,
		57, 1, 57, 1, 57, 3, 57, 2489, 8, 57, 1, 58, 1, 58, 1, 58, 1, 58, 1, 59,
		1, 59, 1, 59, 3, 59, 2498, 8, 59, 1, 60, 1, 60, 1, 60, 5, 60, 2503, 8,
		60, 10, 60, 12, 60, 2506, 9, 60, 1, 61, 1, 61, 1, 61, 1, 61, 1, 61, 1,
		61, 1, 61, 3, 61, 2515, 8, 61, 3, 61, 2517, 8, 61, 1, 62, 4, 62, 2520,
		8, 62, 11, 62, 12, 62, 2521, 1, 63, 1, 63, 1, 63, 1, 63, 3, 63, 2528, 8,
		63, 1, 63, 1, 63, 1, 63, 1, 63, 3, 63, 2534, 8, 63, 3, 63, 2536, 8, 63,
		1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1,
		64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64,
		1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 3, 64, 2564, 8, 64, 1, 65, 1, 65, 1,
		65, 1, 66, 1, 66, 1, 66, 5, 66, 2572, 8, 66, 10, 66, 12, 66, 2575, 9, 66,
		1, 67, 1, 67, 1, 67, 1, 67, 1, 67, 1, 68, 1, 68, 1, 68, 5, 68, 2585, 8,
		68, 10, 68, 12, 68, 2588, 9, 68, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1,
		69, 1, 69, 1, 69, 1, 69, 3, 69, 2599, 8, 69, 1, 69, 1, 69, 1, 69, 1, 69,
		1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 3, 69, 2613, 8,
		69, 1, 70, 1, 70, 1, 70, 3, 70, 2618, 8, 70, 1, 71, 1, 71, 1, 71, 1, 71,
		1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1,
		71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 3, 71, 2642, 8, 71,
		1, 72, 1, 72, 1, 73, 1, 73, 3, 73, 2648, 8, 73, 1, 74, 1, 74, 1, 74, 3,
		74, 2653, 8, 74, 1, 75, 1, 75, 1, 75, 1, 75, 1, 75, 3, 75, 2660, 8, 75,
		1, 76, 5, 76, 2663, 8, 76, 10, 76, 12, 76, 2666, 9, 76, 1, 77, 1, 77, 1,
		77, 1, 77, 1, 77, 1, 77, 1, 77, 1, 77, 1, 77, 1, 77, 1, 77, 1, 77, 1, 77,
		1, 77, 1, 77, 1, 77, 1, 77, 1, 77, 1, 77, 1, 77, 1, 77, 1, 77, 1, 77, 1,
		77, 1, 77, 1, 77, 1, 77, 1, 77, 1, 77, 1, 77, 1, 77, 1, 77, 1, 77, 1, 77,
		1, 77, 3, 77, 2703, 8, 77, 1, 78, 1, 78, 3, 78, 2707, 8, 78, 1, 79, 1,
		79, 1, 79, 1, 79, 1, 79, 3, 79, 2714, 8, 79, 1, 80, 1, 80, 3, 80, 2718,
		8, 80, 1, 81, 1, 81, 1, 81, 5, 81, 2723, 8, 81, 10, 81, 12, 81, 2726, 9,
		81, 1, 82, 1, 82, 1, 82, 1, 83, 1, 83, 1, 83, 1, 83, 1, 83, 1, 83, 1, 83,
		1, 83, 3, 83, 2739, 8, 83, 1, 84, 1, 84, 1, 84, 5, 84, 2744, 8, 84, 10,
		84, 12, 84, 2747, 9, 84, 1, 85, 1, 85, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86,
		1, 86, 3, 86, 2757, 8, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1,
		86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86,
		1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1,
		86, 1, 86, 1, 86, 1, 86, 3, 86, 2790, 8, 86, 1, 87, 1, 87, 1, 87, 1, 87,
		1, 87, 1, 87, 1, 87, 1, 87, 3, 87, 2800, 8, 87, 1, 88, 1, 88, 3, 88, 2804,
		8, 88, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 3, 89, 2811, 8, 89, 1, 90, 1,
		90, 1, 90, 5, 90, 2816, 8, 90, 10, 90, 12, 90, 2819, 9, 90, 1, 91, 1, 91,
		1, 91, 5, 91, 2824, 8, 91, 10, 91, 12, 91, 2827, 9, 91, 1, 92, 1, 92, 1,
		92, 3, 92, 2832, 8, 92, 1, 93, 1, 93, 3, 93, 2836, 8, 93, 1, 94, 1, 94,
		1, 94, 1, 94, 1, 94, 1, 95, 1, 95, 1, 95, 3, 95, 2846, 8, 95, 1, 95, 1,
		95, 1, 96, 5, 96, 2851, 8, 96, 10, 96, 12, 96, 2854, 9, 96, 1, 97, 1, 97,
		1, 97, 1, 97, 1, 97, 1, 97, 1, 97, 1, 97, 3, 97, 2864, 8, 97, 1, 98, 1,
		98, 1, 98, 1, 98, 1, 98, 1, 98, 1, 98, 1, 98, 1, 98, 1, 98, 1, 98, 1, 98,
		1, 98, 1, 98, 1, 98, 1, 98, 1, 98, 1, 98, 1, 98, 1, 98, 1, 98, 1, 98, 1,
		98, 1, 98, 1, 98, 1, 98, 1, 98, 1, 98, 1, 98, 1, 98, 3, 98, 2896, 8, 98,
		1, 98, 1, 98, 1, 98, 1, 98, 1, 98, 1, 98, 3, 98, 2904, 8, 98, 1, 99, 1,
		99, 1, 99, 3, 99, 2909, 8, 99, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100,
		3, 100, 2916, 8, 100, 1, 101, 1, 101, 1, 101, 1, 101, 1, 102, 1, 102, 5,
		102, 2924, 8, 102, 10, 102, 12, 102, 2927, 9, 102, 1, 103, 1, 103, 1, 104,
		1, 104, 1, 104, 1, 104, 1, 104, 3, 104, 2936, 8, 104, 1, 105, 1, 105, 1,
		105, 1, 105, 1, 105, 1, 105, 1, 105, 1, 105, 1, 105, 1, 105, 1, 105, 1,
		105, 1, 105, 1, 105, 1, 105, 1, 105, 1, 105, 1, 105, 3, 105, 2956, 8, 105,
		1, 105, 1, 105, 1, 105, 1, 105, 1, 105, 1, 105, 1, 105, 1, 105, 1, 105,
		1, 105, 1, 105, 1, 105, 1, 105, 3, 105, 2971, 8, 105, 1, 105, 1, 105, 1,
		105, 1, 105, 1, 105, 1, 105, 1, 105, 1, 105, 1, 105, 1, 105, 1, 105, 1,
		105, 1, 105, 1, 105, 1, 105, 1, 105, 1, 105, 1, 105, 1, 105, 1, 105, 1,
		105, 1, 105, 1, 105, 3, 105, 2996, 8, 105, 1, 106, 1, 106, 1, 106, 3, 106,
		3001, 8, 106, 1, 107, 1, 107, 1, 107, 1, 107, 1, 107, 3, 107, 3008, 8,
		107, 1, 108, 1, 108, 1, 108, 5, 108, 3013, 8, 108, 10, 108, 12, 108, 3016,
		9, 108, 1, 109, 1, 109, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110,
		3, 110, 3026, 8, 110, 1, 111, 1, 111, 1, 111, 3, 111, 3031, 8, 111, 1,
		112, 1, 112, 1, 112, 5, 112, 3036, 8, 112, 10, 112, 12, 112, 3039, 9, 112,
		1, 113, 1, 113, 1, 113, 1, 113, 1, 113, 1, 113, 1, 113, 1, 113, 3, 113,
		3049, 8, 113, 1, 114, 1, 114, 1, 114, 1, 114, 1, 114, 1, 114, 3, 114, 3057,
		8, 114, 1, 115, 1, 115, 1, 115, 1, 115, 1, 115, 1, 115, 1, 115, 1, 115,
		1, 115, 3, 115, 3068, 8, 115, 1, 116, 1, 116, 1, 116, 1, 116, 1, 117, 1,
		117, 1, 117, 1, 117, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 3,
		118, 3084, 8, 118, 1, 119, 1, 119, 1, 119, 1, 119, 1, 119, 1, 119, 3, 119,
		3092, 8, 119, 1, 120, 1, 120, 3, 120, 3096, 8, 120, 1, 121, 1, 121, 1,
		121, 1, 121, 1, 121, 1, 121, 1, 121, 1, 122, 1, 122, 1, 122, 5, 122, 3108,
		8, 122, 10, 122, 12, 122, 3111, 9, 122, 1, 123, 1, 123, 1, 123, 1, 123,
		1, 123, 1, 123, 1, 123, 1, 123, 1, 123, 1, 123, 1, 123, 1, 123, 1, 123,
		1, 123, 3, 123, 3127, 8, 123, 1, 124, 1, 124, 1, 124, 3, 124, 3132, 8,
		124, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 3, 125, 3139, 8, 125, 1, 126,
		1, 126, 1, 126, 1, 126, 1, 126, 1, 126, 1, 126, 3, 126, 3148, 8, 126, 1,
		126, 3, 126, 3151, 8, 126, 1, 127, 1, 127, 1, 127, 3, 127, 3156, 8, 127,
		1, 128, 1, 128, 1, 128, 1, 128, 1, 128, 3, 128, 3163, 8, 128, 1, 129, 1,
		129, 1, 129, 1, 129, 1, 130, 1, 130, 1, 130, 1, 130, 1, 130, 3, 130, 3174,
		8, 130, 1, 130, 1, 130, 1, 130, 1, 130, 1, 130, 1, 130, 1, 130, 1, 131,
		1, 131, 1, 131, 1, 131, 3, 131, 3187, 8, 131, 1, 131, 1, 131, 1, 131, 1,
		131, 1, 131, 1, 132, 1, 132, 1, 132, 1, 132, 1, 132, 1, 132, 3, 132, 3200,
		8, 132, 1, 132, 1, 132, 1, 132, 1, 132, 1, 132, 1, 133, 1, 133, 1, 133,
		1, 133, 1, 133, 1, 133, 1, 133, 1, 134, 1, 134, 1, 134, 1, 134, 3, 134,
		3218, 8, 134, 1, 134, 3, 134, 3221, 8, 134, 1, 135, 1, 135, 1, 135, 1,
		135, 1, 135, 1, 135, 1, 135, 3, 135, 3230, 8, 135, 1, 135, 1, 135, 1, 135,
		1, 135, 1, 135, 1, 136, 1, 136, 1, 136, 1, 136, 1, 136, 1, 136, 1, 137,
		1, 137, 3, 137, 3245, 8, 137, 1, 138, 1, 138, 1, 138, 1, 138, 1, 138, 1,
		138, 1, 138, 1, 139, 1, 139, 1, 139, 1, 139, 1, 139, 1, 139, 3, 139, 3260,
		8, 139, 1, 139, 1, 139, 1, 139, 1, 140, 1, 140, 1, 140, 1, 140, 3, 140,
		3269, 8, 140, 1, 140, 1, 140, 1, 140, 1, 141, 1, 141, 3, 141, 3276, 8,
		141, 1, 142, 1, 142, 1, 142, 1, 142, 1, 142, 3, 142, 3283, 8, 142, 1, 143,
		4, 143, 3286, 8, 143, 11, 143, 12, 143, 3287, 1, 144, 1, 144, 1, 144, 1,
		144, 1, 144, 1, 144, 1, 144, 1, 144, 1, 144, 1, 144, 1, 144, 1, 144, 1,
		144, 1, 144, 1, 144, 1, 144, 1, 144, 1, 144, 1, 144, 1, 144, 1, 144, 1,
		144, 1, 144, 1, 144, 1, 144, 1, 144, 1, 144, 1, 144, 3, 144, 3318, 8, 144,
		3, 144, 3320, 8, 144, 1, 145, 1, 145, 3, 145, 3324, 8, 145, 1, 146, 1,
		146, 1, 146, 1, 146, 1, 146, 1, 146, 3, 146, 3332, 8, 146, 1, 147, 1, 147,
		1, 147, 5, 147, 3337, 8, 147, 10, 147, 12, 147, 3340, 9, 147, 1, 148, 1,
		148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1,
		148, 3, 148, 3353, 8, 148, 1, 149, 1, 149, 3, 149, 3357, 8, 149, 1, 150,
		1, 150, 3, 150, 3361, 8, 150, 1, 151, 1, 151, 1, 151, 3, 151, 3366, 8,
		151, 1, 152, 1, 152, 1, 152, 1, 152, 3, 152, 3372, 8, 152, 1, 153, 1, 153,
		3, 153, 3376, 8, 153, 1, 154, 1, 154, 3, 154, 3380, 8, 154, 1, 155, 1,
		155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 156, 1, 156, 1,
		156, 3, 156, 3393, 8, 156, 1, 157, 1, 157, 1, 157, 1, 157, 3, 157, 3399,
		8, 157, 1, 157, 1, 157, 1, 158, 1, 158, 1, 158, 1, 158, 1, 158, 3, 158,
		3408, 8, 158, 1, 158, 1, 158, 1, 158, 1, 158, 1, 159, 5, 159, 3415, 8,
		159, 10, 159, 12, 159, 3418, 9, 159, 1, 160, 1, 160, 1, 160, 1, 160, 1,
		160, 1, 160, 1, 160, 3, 160, 3427, 8, 160, 1, 161, 1, 161, 1, 161, 1, 161,
		1, 161, 1, 161, 1, 162, 5, 162, 3436, 8, 162, 10, 162, 12, 162, 3439, 9,
		162, 1, 163, 1, 163, 1, 163, 1, 164, 1, 164, 1, 164, 1, 164, 1, 164, 1,
		164, 1, 164, 1, 164, 1, 164, 1, 164, 1, 164, 1, 164, 1, 164, 1, 164, 1,
		164, 1, 164, 1, 164, 1, 164, 1, 164, 1, 164, 1, 164, 1, 164, 1, 164, 1,
		164, 1, 164, 1, 164, 1, 164, 1, 164, 1, 164, 1, 164, 1, 164, 1, 164, 1,
		164, 1, 164, 1, 164, 1, 164, 1, 164, 1, 164, 1, 164, 1, 164, 1, 164, 1,
		164, 1, 164, 1, 164, 1, 164, 1, 164, 1, 164, 1, 164, 1, 164, 1, 164, 1,
		164, 1, 164, 1, 164, 1, 164, 1, 164, 1, 164, 1, 164, 1, 164, 1, 164, 1,
		164, 1, 164, 1, 164, 1, 164, 1, 164, 1, 164, 1, 164, 1, 164, 1, 164, 1,
		164, 1, 164, 1, 164, 1, 164, 1, 164, 1, 164, 1, 164, 1, 164, 1, 164, 1,
		164, 1, 164, 1, 164, 1, 164, 1, 164, 1, 164, 1, 164, 1, 164, 1, 164, 1,
		164, 1, 164, 1, 164, 1, 164, 1, 164, 1, 164, 1, 164, 1, 164, 1, 164, 1,
		164, 1, 164, 1, 164, 1, 164, 1, 164, 1, 164, 1, 164, 1, 164, 1, 164, 3,
		164, 3548, 8, 164, 1, 165, 1, 165, 1, 165, 1, 165, 1, 165, 1, 165, 1, 165,
		1, 165, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166,
		3, 166, 3566, 8, 166, 1, 167, 4, 167, 3569, 8, 167, 11, 167, 12, 167, 3570,
		1, 168, 1, 168, 3, 168, 3575, 8, 168, 1, 169, 1, 169, 1, 169, 1, 169, 1,
		169, 1, 169, 1, 169, 1, 169, 1, 169, 1, 169, 1, 169, 1, 169, 1, 169, 1,
		169, 1, 169, 3, 169, 3592, 8, 169, 1, 170, 1, 170, 1, 170, 1, 170, 1, 170,
		1, 170, 3, 170, 3600, 8, 170, 1, 171, 1, 171, 1, 171, 5, 171, 3605, 8,
		171, 10, 171, 12, 171, 3608, 9, 171, 1, 172, 1, 172, 1, 172, 1, 172, 1,
		172, 1, 173, 1, 173, 1, 173, 5, 173, 3618, 8, 173, 10, 173, 12, 173, 3621,
		9, 173, 1, 174, 1, 174, 1, 174, 1, 174, 1, 174, 1, 174, 1, 174, 3, 174,
		3630, 8, 174, 1, 175, 1, 175, 1, 175, 1, 176, 1, 176, 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, 3, 178, 3664, 8, 178,
		1, 179, 1, 179, 1, 179, 3, 179, 3669, 8, 179, 1, 180, 1, 180, 1, 180, 3,
		180, 3674, 8, 180, 1, 181, 1, 181, 3, 181, 3678, 8, 181, 1, 182, 1, 182,
		1, 182, 1, 182, 1, 182, 1, 182, 3, 182, 3686, 8, 182, 3, 182, 3688, 8,
		182, 1, 183, 1, 183, 1, 183, 1, 183, 1, 183, 1, 183, 1, 183, 1, 183, 1,
		183, 1, 183, 1, 183, 1, 183, 1, 183, 1, 183, 1, 183, 1, 183, 1, 183, 1,
		183, 1, 183, 1, 183, 1, 183, 1, 183, 1, 183, 1, 183, 1, 183, 1, 183, 1,
		183, 1, 183, 1, 183, 1, 183, 1, 183, 1, 183, 1, 183, 1, 183, 1, 183, 1,
		183, 1, 183, 1, 183, 1, 183, 1, 183, 1, 183, 1, 183, 1, 183, 1, 183, 1,
		183, 1, 183, 1, 183, 1, 183, 1, 183, 1, 183, 1, 183, 1, 183, 1, 183, 1,
		183, 1, 183, 1, 183, 3, 183, 3746, 8, 183, 1, 184, 1, 184, 1, 184, 1, 184,
		1, 184, 1, 184, 1, 184, 1, 184, 1, 184, 1, 184, 1, 184, 1, 184, 1, 185,
		1, 185, 1, 185, 3, 185, 3763, 8, 185, 1, 186, 1, 186, 1, 186, 1, 186, 1,
		186, 1, 186, 3, 186, 3771, 8, 186, 1, 187, 1, 187, 1, 187, 1, 187, 1, 187,
		1, 187, 1, 187, 1, 187, 1, 187, 1, 187, 1, 187, 1, 187, 1, 187, 1, 187,
		1, 187, 1, 187, 1, 187, 1, 187, 1, 187, 1, 187, 1, 187, 3, 187, 3794, 8,
		187, 1, 188, 1, 188, 3, 188, 3798, 8, 188, 1, 189, 1, 189, 1, 189, 1, 189,
		1, 189, 1, 189, 1, 189, 1, 189, 1, 189, 1, 189, 1, 189, 1, 189, 1, 189,
		1, 189, 1, 189, 1, 189, 1, 189, 1, 189, 3, 189, 3818, 8, 189, 1, 190, 1,
		190, 1, 190, 1, 190, 1, 190, 1, 190, 1, 190, 1, 190, 1, 190, 1, 191, 1,
		191, 1, 191, 1, 191, 1, 191, 1, 191, 1, 191, 1, 191, 1, 191, 1, 191, 1,
		191, 1, 192, 1, 192, 1, 192, 1, 192, 1, 192, 1, 192, 1, 192, 1, 192, 1,
		192, 1, 193, 1, 193, 1, 193, 1, 193, 1, 193, 1, 193, 3, 193, 3855, 8, 193,
		1, 194, 1, 194, 1, 194, 1, 194, 1, 194, 1, 194, 1, 194, 3, 194, 3864, 8,
		194, 1, 195, 1, 195, 1, 195, 3, 195, 3869, 8, 195, 1, 196, 1, 196, 1, 196,
		3, 196, 3874, 8, 196, 1, 197, 1, 197, 1, 197, 3, 197, 3879, 8, 197, 1,
		198, 1, 198, 1, 198, 3, 198, 3884, 8, 198, 1, 199, 1, 199, 1, 200, 1, 200,
		1, 200, 1, 200, 1, 200, 1, 200, 1, 200, 1, 200, 1, 200, 1, 201, 1, 201,
		1, 202, 1, 202, 1, 202, 1, 202, 1, 202, 1, 202, 1, 202, 1, 202, 1, 202,
		1, 202, 1, 202, 1, 202, 1, 202, 1, 202, 1, 202, 1, 202, 1, 202, 1, 202,
		1, 202, 1, 202, 1, 202, 1, 202, 1, 202, 1, 202, 1, 202, 1, 202, 1, 202,
		1, 202, 1, 202, 1, 202, 1, 202, 1, 202, 1, 202, 1, 202, 1, 202, 1, 202,
		1, 202, 1, 202, 3, 202, 3937, 8, 202, 1, 203, 1, 203, 1, 203, 1, 203, 3,
		203, 3943, 8, 203, 1, 204, 1, 204, 1, 204, 5, 204, 3948, 8, 204, 10, 204,
		12, 204, 3951, 9, 204, 1, 205, 1, 205, 1, 205, 1, 205, 1, 205, 1, 205,
		1, 205, 3, 205, 3960, 8, 205, 1, 206, 1, 206, 1, 206, 3, 206, 3965, 8,
		206, 1, 207, 4, 207, 3968, 8, 207, 11, 207, 12, 207, 3969, 1, 208, 1, 208,
		1, 208, 1, 208, 1, 208, 1, 209, 1, 209, 1, 210, 1, 210, 1, 211, 1, 211,
		1, 212, 1, 212, 1, 212, 1, 212, 1, 212, 3, 212, 3988, 8, 212, 1, 213, 1,
		213, 3, 213, 3992, 8, 213, 1, 214, 1, 214, 1, 215, 1, 215, 1, 215, 1, 215,
		1, 215, 1, 215, 3, 215, 4002, 8, 215, 1, 216, 1, 216, 1, 217, 1, 217, 3,
		217, 4008, 8, 217, 1, 217, 1, 217, 5, 217, 4012, 8, 217, 10, 217, 12, 217,
		4015, 9, 217, 1, 218, 1, 218, 1, 218, 1, 218, 3, 218, 4021, 8, 218, 1,
		219, 1, 219, 1, 219, 3, 219, 4026, 8, 219, 1, 220, 5, 220, 4029, 8, 220,
		10, 220, 12, 220, 4032, 9, 220, 1, 221, 1, 221, 1, 221, 1, 221, 1, 221,
		1, 221, 1, 221, 1, 221, 1, 221, 1, 221, 1, 221, 3, 221, 4045, 8, 221, 1,
		222, 1, 222, 1, 222, 1, 222, 1, 222, 1, 222, 1, 222, 1, 222, 1, 222, 1,
		222, 1, 222, 1, 222, 1, 222, 1, 222, 1, 222, 1, 222, 1, 222, 1, 222, 1,
		222, 1, 222, 1, 222, 1, 222, 1, 222, 1, 222, 1, 222, 1, 222, 3, 222, 4073,
		8, 222, 1, 223, 1, 223, 1, 223, 5, 223, 4078, 8, 223, 10, 223, 12, 223,
		4081, 9, 223, 1, 224, 1, 224, 1, 224, 1, 224, 1, 224, 1, 224, 1, 225, 1,
		225, 1, 225, 5, 225, 4092, 8, 225, 10, 225, 12, 225, 4095, 9, 225, 1, 226,
		1, 226, 1, 226, 1, 226, 1, 226, 1, 226, 1, 227, 1, 227, 1, 227, 1, 227,
		1, 227, 1, 227, 3, 227, 4109, 8, 227, 1, 228, 1, 228, 1, 228, 1, 228, 1,
		228, 1, 228, 1, 228, 1, 228, 1, 228, 1, 229, 1, 229, 1, 229, 1, 229, 1,
		229, 1, 229, 1, 229, 1, 229, 1, 229, 1, 229, 1, 229, 1, 229, 1, 229, 1,
		229, 1, 229, 1, 229, 1, 229, 1, 229, 1, 229, 1, 229, 1, 229, 1, 229, 1,
		229, 1, 229, 1, 229, 1, 229, 1, 229, 1, 229, 1, 229, 1, 229, 1, 229, 1,
		229, 1, 229, 1, 229, 1, 229, 1, 229, 1, 229, 1, 229, 1, 229, 1, 229, 1,
		229, 1, 229, 1, 229, 1, 229, 1, 229, 1, 229, 1, 229, 1, 229, 1, 229, 1,
		229, 1, 229, 1, 229, 1, 229, 1, 229, 1, 229, 1, 229, 1, 229, 1, 229, 1,
		229, 1, 229, 1, 229, 1, 229, 1, 229, 1, 229, 1, 229, 1, 229, 1, 229, 1,
		229, 1, 229, 1, 229, 1, 229, 1, 229, 1, 229, 1, 229, 1, 229, 1, 229, 1,
		229, 1, 229, 1, 229, 1, 229, 1, 229, 1, 229, 1, 229, 1, 229, 1, 229, 1,
		229, 1, 229, 1, 229, 1, 229, 1, 229, 1, 229, 1, 229, 1, 229, 1, 229, 1,
		229, 1, 229, 1, 229, 1, 229, 1, 229, 1, 229, 1, 229, 1, 229, 1, 229, 1,
		229, 1, 229, 1, 229, 3, 229, 4226, 8, 229, 1, 230, 1, 230, 1, 230, 1, 230,
		1, 231, 1, 231, 1, 231, 5, 231, 4235, 8, 231, 10, 231, 12, 231, 4238, 9,
		231, 1, 232, 1, 232, 1, 232, 3, 232, 4243, 8, 232, 1, 233, 1, 233, 1, 233,
		1, 233, 1, 233, 1, 233, 3, 233, 4251, 8, 233, 1, 234, 1, 234, 1, 234, 1,
		234, 1, 235, 1, 235, 1, 235, 5, 235, 4260, 8, 235, 10, 235, 12, 235, 4263,
		9, 235, 1, 236, 1, 236, 1, 236, 1, 236, 1, 237, 1, 237, 3, 237, 4271, 8,
		237, 1, 238, 1, 238, 1, 238, 5, 238, 4276, 8, 238, 10, 238, 12, 238, 4279,
		9, 238, 1, 239, 1, 239, 1, 239, 1, 239, 1, 239, 1, 239, 1, 239, 1, 239,
		1, 239, 1, 239, 1, 239, 1, 239, 1, 239, 1, 239, 1, 239, 1, 239, 1, 239,
		1, 239, 1, 239, 1, 239, 1, 239, 1, 239, 1, 239, 1, 239, 1, 239, 1, 239,
		1, 239, 1, 239, 1, 239, 1, 239, 1, 239, 1, 239, 1, 239, 1, 239, 1, 239,
		1, 239, 1, 239, 3, 239, 4318, 8, 239, 1, 240, 1, 240, 1, 240, 1, 240, 3,
		240, 4324, 8, 240, 1, 241, 1, 241, 1, 241, 1, 241, 1, 241, 1, 241, 1, 241,
		1, 241, 1, 241, 1, 241, 1, 241, 1, 241, 1, 241, 1, 241, 1, 242, 1, 242,
		1, 242, 5, 242, 4343, 8, 242, 10, 242, 12, 242, 4346, 9, 242, 1, 243, 1,
		243, 1, 243, 1, 243, 1, 243, 1, 243, 1, 243, 1, 243, 1, 243, 1, 243, 1,
		243, 1, 243, 1, 243, 1, 243, 1, 243, 1, 243, 1, 243, 1, 243, 1, 243, 1,
		243, 1, 243, 1, 243, 1, 243, 1, 243, 1, 243, 3, 243, 4373, 8, 243, 1, 244,
		1, 244, 3, 244, 4377, 8, 244, 1, 245, 1, 245, 1, 245, 3, 245, 4382, 8,
		245, 1, 246, 1, 246, 1, 246, 1, 246, 1, 246, 1, 246, 1, 246, 3, 246, 4391,
		8, 246, 1, 247, 1, 247, 3, 247, 4395, 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, 3, 249, 4422, 8, 249, 1, 250, 1, 250, 1, 250,
		5, 250, 4427, 8, 250, 10, 250, 12, 250, 4430, 9, 250, 1, 251, 1, 251, 1,
		251, 1, 251, 1, 251, 1, 251, 1, 251, 1, 251, 1, 251, 1, 251, 1, 251, 1,
		251, 3, 251, 4444, 8, 251, 1, 252, 1, 252, 1, 252, 1, 252, 1, 252, 1, 252,
		1, 252, 1, 252, 1, 252, 1, 252, 1, 252, 1, 252, 1, 252, 1, 252, 1, 252,
		1, 252, 1, 252, 1, 252, 3, 252, 4464, 8, 252, 1, 253, 1, 253, 1, 253, 1,
		253, 1, 253, 1, 253, 1, 253, 1, 253, 1, 253, 1, 253, 1, 253, 1, 253, 1,
		253, 1, 253, 1, 253, 1, 253, 1, 253, 1, 253, 3, 253, 4484, 8, 253, 1, 254,
		1, 254, 1, 254, 1, 254, 1, 254, 1, 254, 1, 255, 1, 255, 1, 255, 1, 255,
		1, 255, 1, 255, 1, 255, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256,
		1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256,
		1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256,
		1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256,
		1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256,
		1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256,
		1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256,
		1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256,
		1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256,
		3, 256, 4577, 8, 256, 1, 257, 1, 257, 1, 257, 1, 257, 1, 257, 1, 257, 1,
		257, 1, 257, 1, 257, 1, 257, 1, 257, 1, 257, 1, 257, 1, 257, 1, 257, 1,
		257, 1, 257, 1, 257, 1, 257, 1, 257, 1, 257, 1, 257, 1, 257, 3, 257, 4602,
		8, 257, 1, 258, 1, 258, 1, 258, 1, 258, 1, 258, 3, 258, 4609, 8, 258, 1,
		259, 1, 259, 1, 259, 1, 259, 1, 259, 1, 259, 1, 259, 1, 259, 1, 259, 1,
		259, 1, 259, 1, 259, 1, 259, 1, 259, 3, 259, 4625, 8, 259, 1, 260, 1, 260,
		1, 261, 1, 261, 1, 261, 5, 261, 4632, 8, 261, 10, 261, 12, 261, 4635, 9,
		261, 1, 262, 1, 262, 3, 262, 4639, 8, 262, 1, 263, 1, 263, 4, 263, 4643,
		8, 263, 11, 263, 12, 263, 4644, 1, 264, 1, 264, 1, 264, 5, 264, 4650, 8,
		264, 10, 264, 12, 264, 4653, 9, 264, 1, 265, 1, 265, 1, 265, 1, 265, 1,
		265, 1, 265, 1, 266, 1, 266, 1, 266, 1, 266, 1, 266, 3, 266, 4666, 8, 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,
		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,
		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,
		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,
		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,
		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,
		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,
		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,
		1, 267, 1, 267, 1, 267, 3, 267, 4815, 8, 267, 1, 268, 1, 268, 3, 268, 4819,
		8, 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, 1, 269, 1, 269, 1, 269, 1, 269, 1, 269,
		1, 269, 1, 269, 1, 269, 1, 269, 1, 269, 1, 269, 1, 269, 1, 269, 1, 269,
		1, 269, 1, 269, 1, 269, 1, 269, 1, 269, 1, 269, 1, 269, 1, 269, 1, 269,
		1, 269, 1, 269, 1, 269, 1, 269, 1, 269, 1, 269, 1, 269, 1, 269, 1, 269,
		1, 269, 1, 269, 1, 269, 1, 269, 1, 269, 1, 269, 1, 269, 1, 269, 1, 269,
		1, 269, 1, 269, 1, 269, 1, 269, 1, 269, 1, 269, 1, 269, 1, 269, 1, 269,
		1, 269, 1, 269, 1, 269, 1, 269, 1, 269, 1, 269, 1, 269, 1, 269, 1, 269,
		1, 269, 1, 269, 1, 269, 1, 269, 1, 269, 1, 269, 1, 269, 1, 269, 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, 4912, 8, 269, 1, 270, 1, 270, 1, 270, 3, 270, 4917,
		8, 270, 1, 271, 1, 271, 3, 271, 4921, 8, 271, 1, 272, 1, 272, 1, 272, 1,
		272, 3, 272, 4927, 8, 272, 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, 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, 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, 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, 1, 273, 1, 273, 3, 273, 4995, 8, 273, 1,
		274, 1, 274, 1, 275, 1, 275, 3, 275, 5001, 8, 275, 1, 276, 1, 276, 1, 276,
		1, 276, 1, 276, 1, 276, 1, 276, 1, 276, 1, 277, 1, 277, 1, 277, 1, 277,
		1, 277, 1, 277, 1, 277, 1, 277, 1, 277, 1, 277, 1, 277, 1, 277, 1, 277,
		1, 277, 1, 277, 1, 277, 1, 277, 1, 277, 1, 277, 3, 277, 5030, 8, 277, 1,
		278, 1, 278, 1, 278, 1, 278, 1, 278, 1, 278, 1, 278, 1, 278, 1, 278, 1,
		278, 1, 278, 1, 278, 1, 278, 1, 278, 1, 278, 3, 278, 5047, 8, 278, 1, 279,
		1, 279, 1, 279, 5, 279, 5052, 8, 279, 10, 279, 12, 279, 5055, 9, 279, 1,
		280, 1, 280, 1, 280, 1, 280, 1, 280, 1, 280, 1, 280, 1, 280, 1, 280, 3,
		280, 5066, 8, 280, 1, 281, 1, 281, 1, 281, 1, 281, 1, 281, 1, 281, 1, 281,
		1, 281, 1, 281, 1, 281, 1, 281, 1, 281, 1, 281, 1, 281, 1, 281, 1, 281,
		1, 281, 1, 281, 1, 281, 1, 281, 1, 281, 1, 281, 1, 281, 1, 281, 1, 281,
		1, 281, 1, 281, 1, 281, 1, 281, 1, 281, 1, 281, 1, 281, 1, 281, 1, 281,
		1, 281, 1, 281, 1, 281, 1, 281, 1, 281, 1, 281, 1, 281, 1, 281, 1, 281,
		1, 281, 1, 281, 1, 281, 1, 281, 1, 281, 1, 281, 1, 281, 1, 281, 1, 281,
		1, 281, 1, 281, 1, 281, 1, 281, 1, 281, 1, 281, 3, 281, 5126, 8, 281, 1,
		282, 1, 282, 1, 282, 5, 282, 5131, 8, 282, 10, 282, 12, 282, 5134, 9, 282,
		1, 283, 1, 283, 1, 283, 3, 283, 5139, 8, 283, 1, 284, 1, 284, 1, 284, 1,
		284, 3, 284, 5145, 8, 284, 1, 285, 1, 285, 1, 285, 1, 285, 1, 285, 1, 285,
		1, 285, 1, 286, 1, 286, 1, 286, 1, 286, 1, 286, 1, 286, 1, 286, 1, 286,
		1, 286, 1, 286, 1, 286, 1, 286, 1, 286, 1, 286, 1, 286, 1, 286, 1, 286,
		3, 286, 5171, 8, 286, 1, 287, 1, 287, 1, 287, 1, 287, 3, 287, 5177, 8,
		287, 1, 288, 1, 288, 1, 288, 1, 288, 3, 288, 5183, 8, 288, 1, 289, 1, 289,
		1, 289, 1, 289, 1, 289, 1, 289, 1, 290, 5, 290, 5192, 8, 290, 10, 290,
		12, 290, 5195, 9, 290, 1, 291, 1, 291, 1, 291, 1, 291, 1, 291, 1, 291,
		1, 291, 1, 291, 1, 291, 3, 291, 5206, 8, 291, 1, 292, 1, 292, 1, 292, 1,
		292, 1, 292, 1, 292, 1, 292, 1, 292, 1, 292, 1, 292, 1, 292, 1, 292, 1,
		292, 1, 292, 1, 292, 1, 292, 1, 292, 1, 292, 1, 292, 1, 292, 1, 292, 1,
		292, 1, 292, 1, 292, 1, 292, 1, 292, 1, 292, 3, 292, 5235, 8, 292, 1, 293,
		1, 293, 1, 294, 1, 294, 1, 294, 1, 294, 1, 294, 1, 294, 1, 294, 1, 294,
		1, 294, 1, 294, 1, 294, 1, 294, 1, 294, 1, 294, 1, 294, 1, 294, 1, 294,
		1, 294, 1, 294, 1, 294, 1, 294, 1, 294, 1, 294, 1, 294, 1, 294, 1, 294,
		1, 294, 1, 294, 1, 294, 1, 294, 1, 294, 1, 294, 1, 294, 1, 294, 1, 294,
		3, 294, 5274, 8, 294, 1, 295, 1, 295, 3, 295, 5278, 8, 295, 1, 296, 1,
		296, 3, 296, 5282, 8, 296, 1, 297, 1, 297, 3, 297, 5286, 8, 297, 1, 298,
		1, 298, 1, 298, 3, 298, 5291, 8, 298, 1, 299, 1, 299, 1, 299, 5, 299, 5296,
		8, 299, 10, 299, 12, 299, 5299, 9, 299, 1, 300, 1, 300, 1, 300, 1, 300,
		1, 300, 1, 300, 1, 300, 1, 300, 1, 300, 1, 300, 1, 300, 3, 300, 5312, 8,
		300, 1, 301, 1, 301, 1, 301, 1, 301, 1, 301, 1, 301, 1, 301, 1, 301, 1,
		301, 1, 301, 1, 301, 3, 301, 5325, 8, 301, 1, 302, 1, 302, 1, 302, 1, 302,
		1, 302, 1, 302, 3, 302, 5333, 8, 302, 1, 303, 1, 303, 1, 303, 5, 303, 5338,
		8, 303, 10, 303, 12, 303, 5341, 9, 303, 1, 304, 1, 304, 1, 304, 3, 304,
		5346, 8, 304, 1, 305, 1, 305, 3, 305, 5350, 8, 305, 1, 306, 1, 306, 1,
		306, 3, 306, 5355, 8, 306, 1, 307, 1, 307, 1, 307, 1, 307, 1, 307, 3, 307,
		5362, 8, 307, 1, 308, 1, 308, 1, 308, 1, 308, 1, 308, 1, 308, 1, 308, 1,
		308, 1, 308, 1, 308, 1, 308, 1, 308, 3, 308, 5376, 8, 308, 3, 308, 5378,
		8, 308, 1, 308, 1, 308, 1, 309, 1, 309, 1, 309, 3, 309, 5385, 8, 309, 1,
		310, 1, 310, 3, 310, 5389, 8, 310, 1, 310, 1, 310, 1, 311, 1, 311, 1, 311,
		5, 311, 5396, 8, 311, 10, 311, 12, 311, 5399, 9, 311, 1, 312, 1, 312, 1,
		312, 5, 312, 5404, 8, 312, 10, 312, 12, 312, 5407, 9, 312, 1, 313, 1, 313,
		1, 313, 1, 313, 1, 313, 1, 313, 3, 313, 5415, 8, 313, 3, 313, 5417, 8,
		313, 1, 314, 1, 314, 3, 314, 5421, 8, 314, 1, 314, 1, 314, 1, 315, 1, 315,
		1, 315, 5, 315, 5428, 8, 315, 10, 315, 12, 315, 5431, 9, 315, 1, 316, 1,
		316, 3, 316, 5435, 8, 316, 1, 316, 1, 316, 1, 316, 1, 316, 3, 316, 5441,
		8, 316, 1, 316, 1, 316, 1, 316, 3, 316, 5446, 8, 316, 1, 317, 1, 317, 3,
		317, 5450, 8, 317, 1, 317, 1, 317, 1, 317, 3, 317, 5455, 8, 317, 1, 318,
		1, 318, 1, 318, 1, 318, 3, 318, 5461, 8, 318, 1, 319, 1, 319, 1, 320, 1,
		320, 3, 320, 5467, 8, 320, 1, 320, 1, 320, 1, 320, 1, 320, 3, 320, 5473,
		8, 320, 1, 320, 1, 320, 1, 320, 1, 320, 3, 320, 5479, 8, 320, 1, 321, 1,
		321, 1, 321, 3, 321, 5484, 8, 321, 1, 322, 1, 322, 1, 323, 1, 323, 1, 323,
		1, 323, 1, 323, 1, 323, 1, 323, 1, 323, 1, 323, 1, 323, 1, 323, 3, 323,
		5499, 8, 323, 1, 323, 1, 323, 1, 324, 1, 324, 1, 324, 5, 324, 5506, 8,
		324, 10, 324, 12, 324, 5509, 9, 324, 1, 325, 1, 325, 1, 325, 1, 326, 1,
		326, 1, 326, 5, 326, 5517, 8, 326, 10, 326, 12, 326, 5520, 9, 326, 1, 327,
		4, 327, 5523, 8, 327, 11, 327, 12, 327, 5524, 1, 327, 1, 327, 1, 328, 1,
		328, 1, 328, 1, 328, 1, 328, 1, 328, 1, 328, 1, 328, 1, 328, 1, 328, 1,
		328, 1, 328, 1, 328, 1, 328, 1, 328, 1, 328, 1, 328, 1, 328, 1, 328, 1,
		328, 1, 328, 1, 328, 1, 328, 1, 328, 1, 328, 1, 328, 1, 328, 1, 328, 1,
		328, 1, 328, 1, 328, 1, 328, 1, 328, 1, 328, 1, 328, 3, 328, 5564, 8, 328,
		1, 329, 1, 329, 1, 329, 1, 329, 1, 329, 1, 329, 1, 329, 1, 329, 3, 329,
		5574, 8, 329, 1, 330, 1, 330, 1, 330, 1, 330, 1, 330, 3, 330, 5581, 8,
		330, 1, 331, 1, 331, 1, 331, 1, 331, 1, 331, 1, 331, 1, 331, 5, 331, 5590,
		8, 331, 10, 331, 12, 331, 5593, 9, 331, 1, 332, 1, 332, 1, 332, 3, 332,
		5598, 8, 332, 1, 333, 1, 333, 1, 333, 1, 334, 1, 334, 1, 334, 5, 334, 5606,
		8, 334, 10, 334, 12, 334, 5609, 9, 334, 1, 335, 1, 335, 1, 335, 1, 335,
		1, 335, 1, 335, 1, 336, 4, 336, 5618, 8, 336, 11, 336, 12, 336, 5619, 1,
		337, 1, 337, 3, 337, 5624, 8, 337, 1, 338, 1, 338, 1, 338, 1, 338, 1, 338,
		1, 338, 1, 338, 1, 338, 1, 338, 1, 338, 1, 338, 1, 338, 1, 338, 1, 338,
		1, 338, 1, 338, 1, 338, 1, 338, 1, 338, 1, 338, 1, 338, 1, 338, 1, 338,
		1, 338, 1, 338, 1, 338, 1, 338, 1, 338, 1, 338, 1, 338, 1, 338, 1, 338,
		1, 338, 1, 338, 1, 338, 1, 338, 3, 338, 5662, 8, 338, 1, 339, 1, 339, 1,
		339, 1, 339, 1, 339, 1, 339, 1, 339, 1, 339, 1, 339, 1, 339, 1, 339, 1,
		339, 3, 339, 5676, 8, 339, 1, 340, 1, 340, 1, 340, 1, 340, 1, 340, 1, 340,
		1, 340, 1, 340, 1, 340, 1, 340, 1, 340, 1, 340, 3, 340, 5690, 8, 340, 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, 1, 341, 1,
		341, 1, 341, 1, 341, 1, 341, 3, 341, 5714, 8, 341, 1, 342, 1, 342, 1, 342,
		5, 342, 5719, 8, 342, 10, 342, 12, 342, 5722, 9, 342, 1, 342, 1, 342, 1,
		343, 1, 343, 1, 343, 5, 343, 5729, 8, 343, 10, 343, 12, 343, 5732, 9, 343,
		1, 344, 1, 344, 1, 344, 1, 345, 1, 345, 1, 345, 1, 346, 4, 346, 5741, 8,
		346, 11, 346, 12, 346, 5742, 1, 347, 1, 347, 1, 347, 3, 347, 5748, 8, 347,
		1, 348, 1, 348, 1, 348, 1, 348, 1, 348, 1, 348, 1, 348, 1, 348, 1, 348,
		1, 348, 1, 348, 1, 348, 1, 348, 1, 348, 1, 348, 1, 348, 1, 348, 1, 348,
		1, 348, 1, 348, 1, 348, 1, 348, 1, 348, 1, 348, 1, 348, 1, 348, 1, 348,
		1, 348, 1, 348, 1, 348, 1, 348, 1, 348, 1, 348, 1, 348, 3, 348, 5784, 8,
		348, 1, 349, 1, 349, 1, 349, 1, 349, 1, 349, 3, 349, 5791, 8, 349, 1, 350,
		1, 350, 1, 350, 1, 350, 1, 350, 1, 350, 1, 350, 1, 350, 1, 350, 1, 350,
		1, 351, 1, 351, 1, 351, 3, 351, 5806, 8, 351, 1, 352, 1, 352, 1, 352, 1,
		352, 1, 352, 1, 352, 1, 352, 1, 352, 1, 352, 1, 352, 1, 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, 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, 5853, 8, 353, 1, 354,
		1, 354, 1, 354, 1, 354, 1, 354, 1, 354, 1, 354, 1, 354, 1, 354, 1, 355,
		1, 355, 1, 355, 1, 355, 1, 355, 1, 355, 1, 355, 1, 355, 1, 355, 1, 355,
		1, 355, 1, 355, 1, 355, 1, 355, 1, 355, 1, 355, 1, 355, 1, 355, 1, 355,
		1, 355, 1, 355, 1, 355, 1, 355, 1, 355, 1, 355, 1, 355, 3, 355, 5890, 8,
		355, 1, 356, 1, 356, 1, 357, 1, 357, 1, 358, 1, 358, 1, 358, 5, 358, 5899,
		8, 358, 10, 358, 12, 358, 5902, 9, 358, 1, 359, 1, 359, 1, 360, 1, 360,
		1, 360, 1, 360, 1, 360, 1, 360, 1, 360, 1, 360, 1, 360, 1, 360, 1, 360,
		1, 360, 3, 360, 5918, 8, 360, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1,
		361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1,
		361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1,
		361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1,
		361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1,
		361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1,
		361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1,
		361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1,
		361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1,
		361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1,
		361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1,
		361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1,
		361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1,
		361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1,
		361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1,
		361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1,
		361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1,
		361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1,
		361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1,
		361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1,
		361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1,
		361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1,
		361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1,
		361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1,
		361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1,
		361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1,
		361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1,
		361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1,
		361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1,
		361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1,
		361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1,
		361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1,
		361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1,
		361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1,
		361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1,
		361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1,
		361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1,
		361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1,
		361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1,
		361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1,
		361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1,
		361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1,
		361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1,
		361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1,
		361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1,
		361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1,
		361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1,
		361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1,
		361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1,
		361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1,
		361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1,
		361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1,
		361, 1, 361, 1, 361, 1, 361, 3, 361, 6388, 8, 361, 1, 362, 1, 362, 3, 362,
		6392, 8, 362, 1, 363, 1, 363, 1, 363, 3, 363, 6397, 8, 363, 1, 364, 1,
		364, 1, 364, 1, 364, 1, 364, 1, 364, 1, 364, 1, 364, 1, 364, 1, 364, 1,
		364, 1, 364, 1, 364, 1, 364, 1, 364, 1, 364, 1, 364, 1, 364, 1, 364, 1,
		364, 1, 364, 1, 364, 1, 364, 1, 364, 1, 364, 1, 364, 1, 364, 1, 364, 1,
		364, 1, 364, 1, 364, 1, 364, 1, 364, 1, 364, 1, 364, 1, 364, 1, 364, 1,
		364, 1, 364, 1, 364, 1, 364, 1, 364, 1, 364, 1, 364, 1, 364, 1, 364, 1,
		364, 1, 364, 1, 364, 1, 364, 1, 364, 1, 364, 1, 364, 1, 364, 1, 364, 1,
		364, 1, 364, 3, 364, 6456, 8, 364, 1, 365, 1, 365, 3, 365, 6460, 8, 365,
		1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366,
		1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366,
		1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366,
		1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366,
		1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366,
		1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366,
		1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366,
		1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366,
		1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366,
		1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366,
		1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366,
		1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366,
		1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366,
		1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366,
		1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366,
		1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366,
		1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366,
		1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366,
		1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366,
		1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366,
		1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366,
		1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366,
		1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366,
		1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366,
		1, 366, 3, 366, 6679, 8, 366, 1, 367, 1, 367, 1, 367, 1, 367, 1, 367, 1,
		367, 1, 367, 1, 367, 1, 368, 1, 368, 1, 368, 5, 368, 6692, 8, 368, 10,
		368, 12, 368, 6695, 9, 368, 1, 369, 1, 369, 1, 369, 1, 369, 1, 369, 1,
		369, 1, 369, 1, 369, 3, 369, 6705, 8, 369, 1, 370, 1, 370, 1, 370, 1, 370,
		1, 370, 3, 370, 6712, 8, 370, 1, 371, 1, 371, 1, 371, 1, 371, 1, 371, 1,
		371, 1, 371, 1, 371, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1,
		372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1,
		372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1,
		372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1,
		372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1,
		372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1,
		372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1,
		372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1,
		372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1,
		372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1,
		372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1,
		372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1,
		372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1,
		372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1,
		372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1,
		372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1,
		372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1,
		372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1,
		372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1,
		372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1,
		372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 3, 372, 6905, 8, 372, 1, 373,
		1, 373, 1, 373, 1, 373, 1, 373, 1, 373, 1, 374, 1, 374, 3, 374, 6915, 8,
		374, 1, 375, 1, 375, 1, 375, 1, 375, 1, 375, 1, 375, 3, 375, 6923, 8, 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,
		3, 376, 6952, 8, 376, 1, 377, 1, 377, 1, 377, 1, 377, 1, 377, 1, 377, 1,
		377, 1, 377, 1, 377, 1, 378, 1, 378, 1, 378, 5, 378, 6966, 8, 378, 10,
		378, 12, 378, 6969, 9, 378, 1, 379, 1, 379, 1, 380, 1, 380, 1, 380, 1,
		380, 1, 380, 1, 380, 1, 380, 1, 380, 1, 380, 1, 380, 1, 380, 1, 380, 1,
		380, 1, 380, 1, 380, 1, 380, 1, 380, 1, 380, 1, 380, 1, 380, 1, 380, 1,
		380, 1, 380, 1, 380, 1, 380, 1, 380, 1, 380, 1, 380, 1, 380, 1, 380, 1,
		380, 1, 380, 1, 380, 1, 380, 1, 380, 1, 380, 1, 380, 3, 380, 7010, 8, 380,
		1, 381, 1, 381, 1, 381, 1, 381, 1, 381, 1, 381, 1, 381, 1, 381, 1, 381,
		1, 381, 1, 381, 1, 381, 3, 381, 7024, 8, 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, 1,
		382, 1, 382, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 3, 383, 7046,
		8, 383, 1, 384, 1, 384, 1, 384, 5, 384, 7051, 8, 384, 10, 384, 12, 384,
		7054, 9, 384, 1, 385, 1, 385, 1, 385, 1, 385, 1, 385, 3, 385, 7061, 8,
		385, 1, 386, 1, 386, 3, 386, 7065, 8, 386, 1, 387, 1, 387, 1, 388, 1, 388,
		1, 388, 3, 388, 7072, 8, 388, 1, 389, 1, 389, 1, 389, 1, 389, 1, 390, 1,
		390, 1, 390, 3, 390, 7081, 8, 390, 1, 391, 1, 391, 1, 391, 1, 392, 1, 392,
		1, 392, 1, 392, 3, 392, 7090, 8, 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, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1,
		393, 3, 393, 7142, 8, 393, 1, 394, 1, 394, 1, 394, 3, 394, 7147, 8, 394,
		1, 395, 1, 395, 1, 395, 1, 395, 1, 395, 1, 395, 1, 395, 1, 395, 1, 395,
		1, 395, 3, 395, 7159, 8, 395, 1, 396, 1, 396, 3, 396, 7163, 8, 396, 1,
		396, 5, 396, 7166, 8, 396, 10, 396, 12, 396, 7169, 9, 396, 1, 397, 1, 397,
		3, 397, 7173, 8, 397, 1, 398, 1, 398, 3, 398, 7177, 8, 398, 1, 398, 1,
		398, 3, 398, 7181, 8, 398, 1, 399, 1, 399, 1, 399, 3, 399, 7186, 8, 399,
		1, 399, 1, 399, 1, 399, 1, 399, 1, 399, 1, 399, 1, 399, 1, 399, 1, 399,
		1, 399, 1, 399, 1, 399, 1, 399, 1, 399, 3, 399, 7202, 8, 399, 1, 399, 1,
		399, 1, 399, 1, 399, 1, 400, 1, 400, 3, 400, 7210, 8, 400, 1, 400, 1, 400,
		1, 400, 3, 400, 7215, 8, 400, 1, 401, 1, 401, 1, 401, 1, 402, 1, 402, 1,
		402, 1, 402, 1, 402, 1, 402, 1, 403, 1, 403, 3, 403, 7228, 8, 403, 1, 404,
		4, 404, 7231, 8, 404, 11, 404, 12, 404, 7232, 1, 405, 1, 405, 1, 405, 1,
		405, 1, 405, 3, 405, 7240, 8, 405, 1, 406, 1, 406, 1, 406, 1, 406, 1, 406,
		1, 406, 1, 406, 1, 406, 3, 406, 7250, 8, 406, 1, 407, 1, 407, 3, 407, 7254,
		8, 407, 1, 408, 1, 408, 1, 408, 1, 408, 1, 408, 1, 408, 1, 408, 1, 408,
		1, 408, 3, 408, 7265, 8, 408, 1, 409, 1, 409, 1, 409, 1, 409, 1, 409, 1,
		410, 1, 410, 1, 410, 1, 410, 3, 410, 7276, 8, 410, 1, 410, 1, 410, 1, 410,
		1, 410, 1, 410, 1, 410, 3, 410, 7284, 8, 410, 1, 411, 1, 411, 1, 411, 5,
		411, 7289, 8, 411, 10, 411, 12, 411, 7292, 9, 411, 1, 412, 1, 412, 1, 413,
		1, 413, 1, 413, 1, 413, 1, 413, 1, 413, 1, 414, 1, 414, 1, 414, 1, 414,
		1, 414, 1, 415, 1, 415, 1, 415, 1, 415, 1, 415, 1, 415, 1, 415, 1, 416,
		1, 416, 1, 416, 1, 416, 1, 416, 1, 416, 1, 416, 1, 416, 1, 416, 1, 416,
		1, 416, 1, 416, 1, 416, 1, 416, 1, 416, 1, 416, 3, 416, 7330, 8, 416, 1,
		416, 1, 416, 1, 416, 1, 416, 1, 416, 1, 416, 3, 416, 7338, 8, 416, 1, 417,
		1, 417, 3, 417, 7342, 8, 417, 1, 418, 1, 418, 1, 418, 1, 418, 1, 418, 1,
		418, 1, 418, 1, 419, 1, 419, 1, 419, 1, 419, 1, 419, 1, 419, 1, 419, 1,
		419, 1, 419, 1, 419, 1, 419, 1, 419, 1, 419, 1, 419, 1, 419, 1, 419, 1,
		419, 1, 419, 1, 419, 1, 419, 1, 419, 1, 419, 1, 419, 1, 419, 1, 419, 1,
		419, 1, 419, 1, 419, 1, 419, 1, 419, 1, 419, 1, 419, 1, 419, 1, 419, 1,
		419, 1, 419, 1, 419, 1, 419, 1, 419, 1, 419, 1, 419, 1, 419, 1, 419, 1,
		419, 1, 419, 1, 419, 1, 419, 1, 419, 1, 419, 1, 419, 1, 419, 1, 419, 1,
		419, 1, 419, 1, 419, 1, 419, 1, 419, 1, 419, 1, 419, 1, 419, 1, 419, 1,
		419, 1, 419, 1, 419, 1, 419, 1, 419, 1, 419, 1, 419, 1, 419, 1, 419, 1,
		419, 1, 419, 3, 419, 7423, 8, 419, 1, 420, 1, 420, 1, 421, 1, 421, 1, 421,
		1, 421, 1, 421, 1, 421, 1, 421, 1, 421, 1, 421, 1, 421, 1, 421, 1, 422,
		1, 422, 1, 422, 1, 422, 1, 422, 1, 422, 1, 422, 1, 422, 1, 422, 1, 422,
		1, 422, 1, 422, 1, 422, 3, 422, 7451, 8, 422, 1, 423, 1, 423, 1, 423, 3,
		423, 7456, 8, 423, 1, 424, 1, 424, 1, 424, 1, 424, 1, 424, 1, 424, 1, 424,
		1, 424, 1, 424, 1, 424, 1, 424, 1, 424, 1, 424, 3, 424, 7471, 8, 424, 1,
		425, 1, 425, 1, 425, 1, 425, 1, 425, 1, 425, 1, 425, 1, 425, 1, 425, 1,
		425, 3, 425, 7483, 8, 425, 1, 426, 1, 426, 1, 426, 5, 426, 7488, 8, 426,
		10, 426, 12, 426, 7491, 9, 426, 1, 427, 1, 427, 1, 428, 1, 428, 1, 428,
		1, 429, 1, 429, 3, 429, 7500, 8, 429, 1, 430, 1, 430, 1, 430, 3, 430, 7505,
		8, 430, 1, 431, 1, 431, 3, 431, 7509, 8, 431, 1, 432, 1, 432, 3, 432, 7513,
		8, 432, 1, 433, 1, 433, 3, 433, 7517, 8, 433, 1, 434, 1, 434, 3, 434, 7521,
		8, 434, 1, 435, 1, 435, 1, 435, 1, 435, 1, 435, 3, 435, 7528, 8, 435, 1,
		436, 1, 436, 1, 436, 1, 437, 1, 437, 1, 437, 5, 437, 7536, 8, 437, 10,
		437, 12, 437, 7539, 9, 437, 1, 438, 1, 438, 3, 438, 7543, 8, 438, 1, 439,
		1, 439, 1, 439, 1, 439, 1, 439, 1, 439, 1, 439, 1, 439, 1, 439, 1, 439,
		1, 439, 1, 439, 1, 439, 1, 439, 1, 439, 1, 439, 3, 439, 7561, 8, 439, 1,
		440, 1, 440, 1, 440, 1, 440, 1, 440, 1, 440, 1, 440, 1, 440, 1, 440, 3,
		440, 7572, 8, 440, 1, 441, 1, 441, 1, 441, 5, 441, 7577, 8, 441, 10, 441,
		12, 441, 7580, 9, 441, 1, 442, 1, 442, 1, 442, 1, 443, 1, 443, 3, 443,
		7587, 8, 443, 1, 444, 1, 444, 1, 444, 3, 444, 7592, 8, 444, 1, 445, 1,
		445, 1, 445, 1, 445, 1, 445, 1, 445, 1, 446, 1, 446, 1, 446, 1, 446, 1,
		446, 3, 446, 7605, 8, 446, 1, 447, 1, 447, 1, 447, 1, 447, 3, 447, 7611,
		8, 447, 1, 448, 1, 448, 1, 448, 1, 448, 1, 448, 1, 448, 1, 448, 1, 448,
		1, 448, 1, 448, 1, 448, 1, 448, 1, 448, 1, 448, 1, 448, 1, 448, 1, 448,
		1, 448, 1, 448, 1, 448, 1, 448, 1, 448, 1, 448, 1, 448, 1, 448, 1, 448,
		1, 448, 3, 448, 7640, 8, 448, 1, 449, 1, 449, 1, 449, 1, 449, 1, 449, 3,
		449, 7647, 8, 449, 1, 450, 1, 450, 1, 450, 1, 450, 1, 450, 1, 450, 1, 450,
		1, 450, 1, 450, 1, 450, 3, 450, 7659, 8, 450, 1, 451, 1, 451, 1, 451, 1,
		451, 1, 451, 1, 451, 1, 451, 1, 451, 1, 452, 1, 452, 1, 452, 3, 452, 7672,
		8, 452, 1, 453, 1, 453, 1, 453, 1, 453, 1, 453, 1, 453, 1, 453, 1, 453,
		1, 453, 1, 453, 1, 453, 1, 453, 1, 453, 3, 453, 7687, 8, 453, 1, 453, 1,
		453, 1, 453, 1, 453, 3, 453, 7693, 8, 453, 1, 454, 1, 454, 1, 455, 1, 455,
		1, 455, 5, 455, 7700, 8, 455, 10, 455, 12, 455, 7703, 9, 455, 1, 456, 1,
		456, 1, 456, 1, 457, 1, 457, 1, 457, 1, 457, 1, 457, 1, 457, 1, 457, 1,
		457, 1, 457, 1, 457, 3, 457, 7718, 8, 457, 1, 457, 3, 457, 7721, 8, 457,
		1, 458, 1, 458, 1, 458, 1, 458, 1, 458, 1, 458, 1, 458, 1, 458, 1, 458,
		3, 458, 7732, 8, 458, 1, 459, 1, 459, 1, 459, 3, 459, 7737, 8, 459, 1,
		460, 1, 460, 3, 460, 7741, 8, 460, 1, 460, 1, 460, 3, 460, 7745, 8, 460,
		1, 460, 1, 460, 1, 460, 3, 460, 7750, 8, 460, 1, 460, 3, 460, 7753, 8,
		460, 1, 460, 1, 460, 1, 460, 1, 460, 3, 460, 7759, 8, 460, 1, 460, 1, 460,
		3, 460, 7763, 8, 460, 3, 460, 7765, 8, 460, 1, 460, 3, 460, 7768, 8, 460,
		1, 461, 1, 461, 1, 461, 1, 461, 1, 461, 3, 461, 7775, 8, 461, 1, 461, 3,
		461, 7778, 8, 461, 1, 461, 1, 461, 1, 461, 1, 461, 1, 461, 3, 461, 7785,
		8, 461, 1, 461, 1, 461, 1, 462, 1, 462, 1, 462, 1, 462, 3, 462, 7793, 8,
		462, 1, 462, 3, 462, 7796, 8, 462, 1, 462, 1, 462, 1, 462, 1, 462, 1, 463,
		1, 463, 1, 463, 3, 463, 7805, 8, 463, 1, 463, 1, 463, 1, 464, 1, 464, 1,
		464, 1, 464, 1, 464, 1, 464, 1, 464, 1, 464, 1, 465, 1, 465, 1, 465, 3,
		465, 7820, 8, 465, 1, 466, 1, 466, 1, 466, 1, 466, 1, 466, 1, 466, 1, 467,
		1, 467, 1, 467, 1, 467, 1, 467, 3, 467, 7833, 8, 467, 1, 468, 1, 468, 1,
		468, 1, 468, 1, 468, 1, 468, 1, 468, 1, 468, 1, 468, 3, 468, 7844, 8, 468,
		1, 468, 3, 468, 7847, 8, 468, 1, 469, 1, 469, 3, 469, 7851, 8, 469, 1,
		470, 1, 470, 1, 470, 1, 470, 3, 470, 7857, 8, 470, 1, 471, 1, 471, 1, 471,
		1, 471, 1, 471, 1, 471, 1, 471, 1, 471, 1, 471, 1, 472, 1, 472, 1, 472,
		5, 472, 7871, 8, 472, 10, 472, 12, 472, 7874, 9, 472, 1, 473, 1, 473, 1,
		473, 1, 473, 1, 473, 1, 473, 1, 473, 1, 473, 1, 473, 1, 473, 3, 473, 7886,
		8, 473, 1, 474, 1, 474, 1, 474, 1, 475, 1, 475, 1, 475, 5, 475, 7894, 8,
		475, 10, 475, 12, 475, 7897, 9, 475, 1, 476, 1, 476, 1, 476, 1, 476, 1,
		476, 1, 476, 1, 476, 1, 476, 1, 477, 1, 477, 1, 478, 1, 478, 1, 478, 1,
		478, 1, 478, 5, 478, 7914, 8, 478, 10, 478, 12, 478, 7917, 9, 478, 1, 479,
		1, 479, 1, 479, 1, 479, 1, 479, 3, 479, 7924, 8, 479, 1, 480, 1, 480, 3,
		480, 7928, 8, 480, 1, 481, 1, 481, 1, 481, 1, 481, 1, 481, 1, 481, 1, 481,
		1, 481, 3, 481, 7938, 8, 481, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1,
		482, 1, 482, 1, 482, 3, 482, 7948, 8, 482, 1, 482, 1, 482, 1, 482, 1, 482,
		1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 3, 482, 7959, 8, 482, 3, 482, 7961,
		8, 482, 1, 483, 1, 483, 1, 483, 1, 483, 1, 483, 5, 483, 7968, 8, 483, 10,
		483, 12, 483, 7971, 9, 483, 1, 484, 1, 484, 1, 484, 1, 484, 1, 484, 5,
		484, 7978, 8, 484, 10, 484, 12, 484, 7981, 9, 484, 1, 485, 1, 485, 1, 485,
		1, 485, 1, 485, 1, 485, 1, 485, 1, 485, 3, 485, 7991, 8, 485, 1, 485, 1,
		485, 1, 485, 1, 485, 1, 485, 1, 485, 1, 485, 1, 485, 1, 485, 1, 485, 1,
		485, 3, 485, 8004, 8, 485, 1, 486, 1, 486, 3, 486, 8008, 8, 486, 1, 486,
		1, 486, 1, 487, 1, 487, 1, 487, 5, 487, 8015, 8, 487, 10, 487, 12, 487,
		8018, 9, 487, 1, 488, 1, 488, 1, 488, 1, 488, 1, 488, 1, 488, 1, 488, 1,
		488, 1, 489, 1, 489, 1, 489, 1, 489, 3, 489, 8032, 8, 489, 1, 490, 1, 490,
		3, 490, 8036, 8, 490, 1, 491, 1, 491, 1, 491, 1, 491, 1, 491, 3, 491, 8043,
		8, 491, 1, 491, 3, 491, 8046, 8, 491, 1, 492, 1, 492, 3, 492, 8050, 8,
		492, 1, 493, 3, 493, 8053, 8, 493, 1, 493, 1, 493, 1, 493, 1, 493, 1, 493,
		1, 493, 1, 493, 1, 493, 1, 493, 1, 493, 1, 493, 3, 493, 8066, 8, 493, 1,
		494, 1, 494, 3, 494, 8070, 8, 494, 1, 495, 1, 495, 1, 495, 3, 495, 8075,
		8, 495, 1, 496, 1, 496, 1, 496, 1, 496, 1, 496, 1, 496, 3, 496, 8083, 8,
		496, 1, 497, 1, 497, 3, 497, 8087, 8, 497, 1, 498, 1, 498, 3, 498, 8091,
		8, 498, 1, 499, 1, 499, 1, 499, 1, 499, 1, 500, 1, 500, 1, 500, 5, 500,
		8100, 8, 500, 10, 500, 12, 500, 8103, 9, 500, 1, 501, 1, 501, 1, 501, 1,
		501, 3, 501, 8109, 8, 501, 1, 501, 1, 501, 1, 502, 1, 502, 3, 502, 8115,
		8, 502, 1, 502, 1, 502, 3, 502, 8119, 8, 502, 3, 502, 8121, 8, 502, 1,
		503, 1, 503, 3, 503, 8125, 8, 503, 1, 504, 1, 504, 1, 504, 1, 504, 3, 504,
		8131, 8, 504, 1, 504, 1, 504, 1, 504, 1, 504, 1, 504, 1, 504, 1, 504, 3,
		504, 8140, 8, 504, 1, 504, 1, 504, 1, 504, 1, 504, 3, 504, 8146, 8, 504,
		3, 504, 8148, 8, 504, 3, 504, 8150, 8, 504, 1, 505, 1, 505, 1, 505, 1,
		505, 1, 505, 3, 505, 8157, 8, 505, 1, 506, 1, 506, 3, 506, 8161, 8, 506,
		1, 507, 1, 507, 1, 508, 1, 508, 1, 508, 1, 508, 1, 508, 3, 508, 8170, 8,
		508, 1, 509, 1, 509, 3, 509, 8174, 8, 509, 1, 510, 1, 510, 1, 511, 1, 511,
		1, 512, 1, 512, 1, 512, 1, 512, 3, 512, 8184, 8, 512, 1, 513, 1, 513, 1,
		513, 5, 513, 8189, 8, 513, 10, 513, 12, 513, 8192, 9, 513, 1, 514, 1, 514,
		1, 514, 1, 514, 1, 514, 3, 514, 8199, 8, 514, 1, 515, 1, 515, 1, 515, 1,
		516, 1, 516, 1, 516, 1, 516, 1, 516, 1, 517, 1, 517, 1, 517, 1, 517, 1,
		517, 1, 518, 1, 518, 1, 518, 1, 518, 1, 518, 1, 518, 1, 519, 1, 519, 1,
		519, 3, 519, 8223, 8, 519, 1, 520, 1, 520, 1, 520, 1, 520, 3, 520, 8229,
		8, 520, 1, 521, 1, 521, 3, 521, 8233, 8, 521, 1, 522, 4, 522, 8236, 8,
		522, 11, 522, 12, 522, 8237, 1, 523, 1, 523, 1, 523, 1, 523, 1, 524, 1,
		524, 1, 524, 3, 524, 8247, 8, 524, 1, 524, 1, 524, 3, 524, 8251, 8, 524,
		1, 524, 3, 524, 8254, 8, 524, 1, 525, 1, 525, 1, 525, 3, 525, 8259, 8,
		525, 1, 526, 1, 526, 1, 526, 1, 526, 1, 526, 1, 526, 1, 526, 1, 526, 1,
		526, 5, 526, 8270, 8, 526, 10, 526, 12, 526, 8273, 9, 526, 1, 527, 1, 527,
		1, 527, 3, 527, 8278, 8, 527, 1, 528, 1, 528, 1, 528, 1, 528, 5, 528, 8284,
		8, 528, 10, 528, 12, 528, 8287, 9, 528, 3, 528, 8289, 8, 528, 1, 529, 1,
		529, 1, 529, 4, 529, 8294, 8, 529, 11, 529, 12, 529, 8295, 1, 530, 1, 530,
		1, 530, 3, 530, 8301, 8, 530, 1, 530, 1, 530, 1, 530, 1, 530, 1, 530, 1,
		530, 1, 530, 1, 530, 1, 530, 1, 530, 1, 530, 1, 530, 1, 530, 1, 530, 1,
		530, 1, 530, 1, 530, 1, 530, 1, 530, 3, 530, 8322, 8, 530, 1, 530, 1, 530,
		1, 530, 1, 530, 1, 530, 1, 530, 1, 530, 3, 530, 8331, 8, 530, 1, 530, 1,
		530, 1, 530, 3, 530, 8336, 8, 530, 1, 530, 1, 530, 1, 530, 1, 530, 3, 530,
		8342, 8, 530, 1, 530, 1, 530, 1, 530, 3, 530, 8347, 8, 530, 1, 530, 1,
		530, 1, 530, 1, 530, 1, 530, 3, 530, 8354, 8, 530, 1, 530, 1, 530, 1, 530,
		3, 530, 8359, 8, 530, 1, 530, 1, 530, 1, 530, 1, 530, 5, 530, 8365, 8,
		530, 10, 530, 12, 530, 8368, 9, 530, 1, 531, 3, 531, 8371, 8, 531, 1, 531,
		1, 531, 1, 531, 1, 531, 1, 531, 3, 531, 8378, 8, 531, 1, 532, 1, 532, 3,
		532, 8382, 8, 532, 1, 533, 3, 533, 8385, 8, 533, 1, 533, 1, 533, 1, 533,
		1, 533, 1, 533, 3, 533, 8392, 8, 533, 1, 534, 1, 534, 1, 534, 3, 534, 8397,
		8, 534, 1, 534, 3, 534, 8400, 8, 534, 1, 534, 1, 534, 1, 534, 1, 534, 1,
		534, 3, 534, 8407, 8, 534, 1, 535, 1, 535, 3, 535, 8411, 8, 535, 1, 536,
		1, 536, 1, 536, 1, 536, 1, 536, 1, 536, 1, 536, 3, 536, 8420, 8, 536, 1,
		537, 1, 537, 3, 537, 8424, 8, 537, 1, 537, 1, 537, 1, 537, 1, 537, 1, 537,
		1, 537, 3, 537, 8432, 8, 537, 3, 537, 8434, 8, 537, 1, 538, 1, 538, 1,
		538, 5, 538, 8439, 8, 538, 10, 538, 12, 538, 8442, 9, 538, 1, 539, 1, 539,
		3, 539, 8446, 8, 539, 1, 539, 3, 539, 8449, 8, 539, 1, 540, 1, 540, 1,
		540, 1, 540, 1, 540, 1, 540, 1, 540, 1, 541, 1, 541, 1, 541, 1, 541, 1,
		541, 1, 541, 3, 541, 8464, 8, 541, 1, 542, 1, 542, 1, 542, 1, 542, 1, 542,
		1, 542, 1, 542, 1, 542, 1, 542, 1, 542, 3, 542, 8476, 8, 542, 1, 543, 1,
		543, 1, 543, 1, 544, 1, 544, 1, 544, 5, 544, 8484, 8, 544, 10, 544, 12,
		544, 8487, 9, 544, 1, 545, 1, 545, 1, 545, 1, 545, 1, 545, 1, 545, 3, 545,
		8495, 8, 545, 1, 546, 1, 546, 1, 546, 3, 546, 8500, 8, 546, 1, 547, 1,
		547, 1, 547, 3, 547, 8505, 8, 547, 1, 548, 1, 548, 1, 548, 1, 548, 1, 548,
		3, 548, 8512, 8, 548, 1, 548, 3, 548, 8515, 8, 548, 1, 549, 1, 549, 3,
		549, 8519, 8, 549, 1, 550, 1, 550, 1, 550, 5, 550, 8524, 8, 550, 10, 550,
		12, 550, 8527, 9, 550, 1, 551, 1, 551, 1, 551, 1, 551, 1, 552, 1, 552,
		1, 552, 1, 552, 1, 552, 1, 552, 1, 552, 1, 552, 1, 552, 1, 552, 1, 552,
		1, 552, 1, 552, 1, 552, 1, 552, 1, 552, 1, 552, 3, 552, 8550, 8, 552, 1,
		552, 1, 552, 1, 553, 1, 553, 1, 553, 5, 553, 8557, 8, 553, 10, 553, 12,
		553, 8560, 9, 553, 1, 554, 1, 554, 1, 554, 3, 554, 8565, 8, 554, 1, 554,
		1, 554, 3, 554, 8569, 8, 554, 1, 555, 4, 555, 8572, 8, 555, 11, 555, 12,
		555, 8573, 1, 556, 1, 556, 1, 556, 1, 556, 1, 556, 1, 556, 1, 556, 1, 556,
		3, 556, 8584, 8, 556, 1, 557, 1, 557, 1, 557, 5, 557, 8589, 8, 557, 10,
		557, 12, 557, 8592, 9, 557, 1, 558, 1, 558, 1, 558, 1, 558, 1, 558, 1,
		558, 3, 558, 8600, 8, 558, 1, 559, 3, 559, 8603, 8, 559, 1, 559, 1, 559,
		1, 559, 1, 559, 1, 559, 1, 559, 1, 559, 3, 559, 8612, 8, 559, 3, 559, 8614,
		8, 559, 1, 559, 1, 559, 1, 559, 1, 559, 3, 559, 8620, 8, 559, 1, 560, 1,
		560, 3, 560, 8624, 8, 560, 1, 560, 5, 560, 8627, 8, 560, 10, 560, 12, 560,
		8630, 9, 560, 1, 561, 1, 561, 1, 561, 1, 561, 1, 561, 1, 561, 1, 561, 1,
		561, 1, 561, 1, 561, 1, 561, 3, 561, 8643, 8, 561, 3, 561, 8645, 8, 561,
		1, 562, 1, 562, 1, 562, 1, 562, 3, 562, 8651, 8, 562, 1, 563, 1, 563, 1,
		563, 1, 563, 3, 563, 8657, 8, 563, 1, 563, 3, 563, 8660, 8, 563, 1, 563,
		1, 563, 1, 564, 1, 564, 1, 564, 1, 564, 1, 564, 3, 564, 8669, 8, 564, 1,
		565, 1, 565, 1, 565, 1, 565, 1, 565, 1, 565, 1, 565, 1, 565, 1, 565, 1,
		565, 1, 565, 1, 565, 1, 565, 1, 565, 1, 565, 1, 565, 3, 565, 8687, 8, 565,
		1, 566, 1, 566, 1, 566, 1, 566, 1, 566, 3, 566, 8694, 8, 566, 1, 567, 1,
		567, 3, 567, 8698, 8, 567, 1, 568, 1, 568, 3, 568, 8702, 8, 568, 1, 569,
		1, 569, 1, 569, 1, 569, 1, 569, 1, 569, 1, 570, 1, 570, 1, 570, 1, 571,
		1, 571, 1, 571, 1, 571, 1, 571, 3, 571, 8718, 8, 571, 1, 572, 1, 572, 1,
		572, 1, 572, 1, 572, 3, 572, 8725, 8, 572, 1, 573, 1, 573, 1, 573, 1, 573,
		1, 573, 1, 573, 3, 573, 8733, 8, 573, 1, 574, 1, 574, 3, 574, 8737, 8,
		574, 1, 575, 1, 575, 1, 575, 1, 575, 1, 575, 3, 575, 8744, 8, 575, 1, 575,
		1, 575, 1, 576, 1, 576, 1, 577, 1, 577, 1, 577, 1, 577, 1, 577, 1, 577,
		1, 577, 3, 577, 8757, 8, 577, 1, 578, 1, 578, 1, 578, 1, 578, 1, 578, 1,
		578, 1, 578, 1, 578, 1, 578, 1, 578, 1, 578, 1, 578, 1, 578, 1, 578, 3,
		578, 8773, 8, 578, 1, 578, 1, 578, 1, 578, 1, 578, 3, 578, 8779, 8, 578,
		1, 578, 1, 578, 1, 578, 1, 578, 3, 578, 8785, 8, 578, 1, 579, 1, 579, 1,
		579, 1, 579, 1, 579, 3, 579, 8792, 8, 579, 1, 580, 1, 580, 1, 580, 3, 580,
		8797, 8, 580, 1, 581, 1, 581, 1, 582, 1, 582, 3, 582, 8803, 8, 582, 1,
		583, 1, 583, 1, 583, 5, 583, 8808, 8, 583, 10, 583, 12, 583, 8811, 9, 583,
		1, 584, 1, 584, 1, 584, 5, 584, 8816, 8, 584, 10, 584, 12, 584, 8819, 9,
		584, 1, 585, 1, 585, 1, 585, 5, 585, 8824, 8, 585, 10, 585, 12, 585, 8827,
		9, 585, 1, 586, 1, 586, 3, 586, 8831, 8, 586, 1, 586, 1, 586, 3, 586, 8835,
		8, 586, 1, 586, 1, 586, 1, 586, 1, 586, 3, 586, 8841, 8, 586, 1, 587, 1,
		587, 3, 587, 8845, 8, 587, 1, 587, 1, 587, 3, 587, 8849, 8, 587, 1, 588,
		3, 588, 8852, 8, 588, 1, 588, 1, 588, 1, 589, 1, 589, 3, 589, 8858, 8,
		589, 1, 590, 1, 590, 1, 590, 3, 590, 8863, 8, 590, 1, 590, 1, 590, 1, 590,
		1, 590, 1, 590, 1, 590, 1, 590, 1, 590, 1, 590, 1, 590, 1, 590, 1, 590,
		1, 590, 1, 590, 3, 590, 8879, 8, 590, 1, 590, 3, 590, 8882, 8, 590, 3,
		590, 8884, 8, 590, 1, 591, 1, 591, 1, 591, 1, 591, 1, 591, 1, 591, 1, 591,
		1, 591, 1, 591, 1, 591, 3, 591, 8896, 8, 591, 3, 591, 8898, 8, 591, 1,
		592, 1, 592, 3, 592, 8902, 8, 592, 1, 592, 1, 592, 1, 592, 1, 592, 3, 592,
		8908, 8, 592, 1, 592, 1, 592, 1, 592, 3, 592, 8913, 8, 592, 1, 593, 1,
		593, 1, 593, 1, 593, 5, 593, 8919, 8, 593, 10, 593, 12, 593, 8922, 9, 593,
		1, 594, 3, 594, 8925, 8, 594, 1, 594, 1, 594, 1, 595, 1, 595, 1, 595, 5,
		595, 8932, 8, 595, 10, 595, 12, 595, 8935, 9, 595, 1, 596, 1, 596, 1, 596,
		5, 596, 8940, 8, 596, 10, 596, 12, 596, 8943, 9, 596, 1, 597, 1, 597, 1,
		597, 3, 597, 8948, 8, 597, 1, 598, 3, 598, 8951, 8, 598, 1, 598, 1, 598,
		1, 599, 1, 599, 1, 599, 1, 599, 1, 599, 3, 599, 8960, 8, 599, 1, 600, 1,
		600, 1, 600, 3, 600, 8965, 8, 600, 1, 601, 1, 601, 1, 601, 5, 601, 8970,
		8, 601, 10, 601, 12, 601, 8973, 9, 601, 1, 602, 1, 602, 1, 602, 1, 602,
		1, 602, 1, 602, 1, 602, 3, 602, 8982, 8, 602, 1, 602, 1, 602, 1, 602, 1,
		602, 1, 602, 1, 602, 1, 602, 1, 602, 1, 602, 1, 602, 1, 602, 1, 602, 1,
		602, 1, 602, 1, 602, 1, 602, 1, 602, 1, 602, 1, 602, 1, 602, 1, 602, 1,
		602, 1, 602, 1, 602, 3, 602, 9008, 8, 602, 1, 602, 1, 602, 1, 602, 1, 602,
		1, 602, 1, 602, 1, 602, 1, 602, 1, 602, 3, 602, 9019, 8, 602, 5, 602, 9021,
		8, 602, 10, 602, 12, 602, 9024, 9, 602, 1, 603, 1, 603, 1, 603, 1, 603,
		1, 603, 3, 603, 9031, 8, 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, 1, 603, 1,
		603, 1, 603, 1, 603, 1, 603, 1, 603, 1, 603, 1, 603, 3, 603, 9054, 8, 603,
		1, 603, 1, 603, 1, 603, 1, 603, 1, 603, 1, 603, 3, 603, 9062, 8, 603, 1,
		604, 1, 604, 1, 605, 1, 605, 1, 605, 1, 605, 1, 605, 1, 605, 3, 605, 9072,
		8, 605, 1, 605, 1, 605, 1, 605, 1, 605, 1, 605, 1, 605, 1, 605, 1, 605,
		1, 605, 1, 605, 1, 605, 1, 605, 3, 605, 9086, 8, 605, 1, 605, 1, 605, 1,
		606, 1, 606, 1, 606, 1, 606, 1, 606, 1, 606, 3, 606, 9096, 8, 606, 1, 607,
		1, 607, 3, 607, 9100, 8, 607, 1, 608, 1, 608, 1, 608, 1, 608, 1, 608, 1,
		608, 1, 608, 1, 608, 1, 608, 1, 608, 1, 608, 1, 608, 3, 608, 9114, 8, 608,
		1, 608, 1, 608, 1, 608, 1, 608, 1, 608, 3, 608, 9121, 8, 608, 1, 608, 1,
		608, 1, 608, 1, 608, 1, 608, 3, 608, 9128, 8, 608, 1, 608, 1, 608, 1, 608,
		1, 608, 1, 608, 3, 608, 9135, 8, 608, 1, 608, 1, 608, 1, 608, 1, 608, 1,
		608, 1, 608, 1, 608, 1, 608, 1, 608, 1, 608, 1, 608, 1, 608, 1, 608, 1,
		608, 1, 608, 1, 608, 1, 608, 1, 608, 1, 608, 1, 608, 1, 608, 1, 608, 1,
		608, 3, 608, 9160, 8, 608, 1, 608, 1, 608, 1, 608, 1, 608, 1, 608, 1, 608,
		1, 608, 1, 608, 1, 608, 1, 608, 1, 608, 1, 608, 1, 608, 1, 608, 1, 608,
		1, 608, 1, 608, 1, 608, 1, 608, 1, 608, 1, 608, 1, 608, 1, 608, 1, 608,
		1, 608, 1, 608, 1, 608, 3, 608, 9189, 8, 608, 1, 608, 1, 608, 1, 608, 1,
		608, 1, 608, 1, 608, 1, 608, 1, 608, 1, 608, 1, 608, 1, 608, 1, 608, 1,
		608, 1, 608, 1, 608, 1, 608, 1, 608, 1, 608, 1, 608, 1, 608, 1, 608, 1,
		608, 1, 608, 1, 608, 1, 608, 1, 608, 1, 608, 1, 608, 1, 608, 1, 608, 1,
		608, 1, 608, 1, 608, 1, 608, 1, 608, 1, 608, 1, 608, 3, 608, 9228, 8, 608,
		3, 608, 9230, 8, 608, 1, 608, 1, 608, 1, 608, 1, 608, 1, 608, 1, 608, 1,
		608, 1, 608, 1, 608, 1, 608, 1, 608, 1, 608, 1, 608, 1, 608, 1, 608, 1,
		608, 1, 608, 1, 608, 1, 608, 1, 608, 1, 608, 1, 608, 1, 608, 1, 608, 1,
		608, 1, 608, 3, 608, 9258, 8, 608, 1, 608, 1, 608, 1, 608, 1, 608, 1, 608,
		1, 608, 1, 608, 1, 608, 1, 608, 1, 608, 1, 608, 1, 608, 1, 608, 1, 608,
		1, 608, 1, 608, 1, 608, 1, 608, 1, 608, 3, 608, 9279, 8, 608, 1, 609, 1,
		609, 1, 609, 1, 609, 1, 609, 3, 609, 9286, 8, 609, 1, 610, 1, 610, 1, 610,
		1, 610, 1, 610, 1, 610, 1, 610, 1, 610, 1, 610, 1, 610, 1, 610, 3, 610,
		9299, 8, 610, 1, 611, 1, 611, 1, 611, 1, 611, 1, 611, 1, 612, 1, 612, 1,
		612, 5, 612, 9309, 8, 612, 10, 612, 12, 612, 9312, 9, 612, 1, 613, 1, 613,
		1, 613, 3, 613, 9317, 8, 613, 1, 614, 1, 614, 1, 615, 1, 615, 1, 615, 1,
		615, 1, 615, 3, 615, 9326, 8, 615, 1, 616, 1, 616, 1, 616, 1, 616, 1, 616,
		1, 616, 1, 616, 1, 616, 1, 616, 1, 616, 1, 616, 1, 616, 1, 616, 1, 616,
		1, 616, 3, 616, 9343, 8, 616, 1, 617, 1, 617, 1, 617, 1, 618, 1, 618, 1,
		618, 1, 618, 1, 618, 1, 618, 1, 618, 3, 618, 9355, 8, 618, 1, 619, 1, 619,
		1, 619, 1, 619, 1, 619, 1, 619, 1, 619, 3, 619, 9364, 8, 619, 1, 620, 1,
		620, 1, 620, 3, 620, 9369, 8, 620, 1, 621, 1, 621, 1, 621, 5, 621, 9374,
		8, 621, 10, 621, 12, 621, 9377, 9, 621, 1, 622, 1, 622, 1, 622, 1, 622,
		1, 623, 1, 623, 1, 623, 3, 623, 9386, 8, 623, 1, 623, 3, 623, 9389, 8,
		623, 1, 624, 1, 624, 1, 624, 1, 624, 1, 624, 1, 624, 1, 624, 1, 625, 1,
		625, 3, 625, 9400, 8, 625, 1, 626, 1, 626, 1, 626, 1, 626, 3, 626, 9406,
		8, 626, 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, 9421, 8, 627, 1, 628, 1,
		628, 1, 628, 1, 628, 1, 628, 1, 628, 3, 628, 9429, 8, 628, 1, 629, 1, 629,
		1, 629, 1, 629, 1, 629, 1, 629, 1, 629, 3, 629, 9438, 8, 629, 1, 630, 1,
		630, 1, 630, 1, 630, 1, 630, 1, 630, 1, 630, 3, 630, 9447, 8, 630, 1, 630,
		3, 630, 9450, 8, 630, 1, 631, 1, 631, 1, 631, 3, 631, 9455, 8, 631, 1,
		631, 1, 631, 1, 631, 1, 631, 1, 631, 1, 631, 1, 631, 3, 631, 9464, 8, 631,
		1, 632, 1, 632, 1, 632, 3, 632, 9469, 8, 632, 1, 632, 1, 632, 1, 633, 1,
		633, 1, 633, 1, 633, 1, 633, 1, 633, 1, 634, 1, 634, 1, 635, 1, 635, 3,
		635, 9483, 8, 635, 1, 636, 1, 636, 1, 637, 1, 637, 1, 637, 1, 637, 1, 637,
		1, 637, 3, 637, 9493, 8, 637, 1, 638, 1, 638, 1, 638, 1, 638, 1, 638, 1,
		638, 3, 638, 9501, 8, 638, 1, 639, 1, 639, 1, 639, 1, 639, 1, 639, 1, 639,
		1, 639, 1, 639, 1, 639, 1, 639, 1, 639, 1, 639, 3, 639, 9515, 8, 639, 1,
		640, 1, 640, 1, 640, 5, 640, 9520, 8, 640, 10, 640, 12, 640, 9523, 9, 640,
		1, 641, 1, 641, 1, 641, 5, 641, 9528, 8, 641, 10, 641, 12, 641, 9531, 9,
		641, 1, 642, 1, 642, 1, 642, 1, 642, 1, 642, 3, 642, 9538, 8, 642, 1, 643,
		1, 643, 1, 643, 5, 643, 9543, 8, 643, 10, 643, 12, 643, 9546, 9, 643, 1,
		644, 1, 644, 1, 644, 3, 644, 9551, 8, 644, 1, 644, 1, 644, 1, 645, 1, 645,
		1, 645, 5, 645, 9558, 8, 645, 10, 645, 12, 645, 9561, 9, 645, 1, 646, 1,
		646, 1, 646, 1, 646, 1, 646, 3, 646, 9568, 8, 646, 1, 647, 1, 647, 1, 647,
		1, 647, 1, 647, 1, 647, 1, 647, 1, 647, 3, 647, 9578, 8, 647, 1, 648, 1,
		648, 1, 649, 1, 649, 1, 649, 1, 649, 1, 649, 1, 649, 1, 649, 3, 649, 9589,
		8, 649, 1, 650, 1, 650, 1, 650, 1, 650, 1, 650, 3, 650, 9596, 8, 650, 1,
		651, 1, 651, 1, 651, 1, 651, 1, 651, 1, 651, 1, 651, 1, 651, 1, 651, 1,
		651, 1, 651, 1, 651, 1, 651, 1, 651, 1, 651, 1, 651, 1, 651, 1, 651, 1,
		651, 1, 651, 1, 651, 1, 651, 1, 651, 1, 651, 1, 651, 1, 651, 1, 651, 3,
		651, 9625, 8, 651, 1, 652, 1, 652, 1, 652, 1, 652, 1, 652, 1, 652, 1, 652,
		3, 652, 9634, 8, 652, 1, 653, 1, 653, 1, 653, 1, 653, 1, 653, 3, 653, 9641,
		8, 653, 1, 654, 1, 654, 1, 654, 1, 654, 1, 654, 1, 654, 1, 655, 4, 655,
		9650, 8, 655, 11, 655, 12, 655, 9651, 1, 656, 1, 656, 1, 656, 1, 656, 1,
		656, 1, 657, 1, 657, 1, 657, 3, 657, 9662, 8, 657, 1, 658, 1, 658, 3, 658,
		9666, 8, 658, 1, 659, 1, 659, 3, 659, 9670, 8, 659, 1, 660, 1, 660, 1,
		660, 3, 660, 9675, 8, 660, 1, 660, 1, 660, 1, 660, 1, 660, 1, 660, 1, 660,
		3, 660, 9683, 8, 660, 1, 660, 1, 660, 3, 660, 9687, 8, 660, 1, 661, 1,
		661, 3, 661, 9691, 8, 661, 1, 662, 4, 662, 9694, 8, 662, 11, 662, 12, 662,
		9695, 1, 663, 5, 663, 9699, 8, 663, 10, 663, 12, 663, 9702, 9, 663, 1,
		664, 1, 664, 3, 664, 9706, 8, 664, 1, 665, 1, 665, 1, 665, 5, 665, 9711,
		8, 665, 10, 665, 12, 665, 9714, 9, 665, 1, 666, 1, 666, 1, 666, 1, 666,
		1, 666, 3, 666, 9721, 8, 666, 1, 666, 3, 666, 9724, 8, 666, 1, 667, 1,
		667, 1, 667, 5, 667, 9729, 8, 667, 10, 667, 12, 667, 9732, 9, 667, 1, 668,
		1, 668, 3, 668, 9736, 8, 668, 1, 669, 1, 669, 1, 669, 5, 669, 9741, 8,
		669, 10, 669, 12, 669, 9744, 9, 669, 1, 670, 1, 670, 1, 671, 1, 671, 1,
		672, 1, 672, 1, 673, 1, 673, 1, 673, 1, 673, 1, 673, 1, 673, 1, 673, 3,
		673, 9759, 8, 673, 1, 674, 1, 674, 1, 674, 1, 674, 1, 674, 1, 674, 1, 674,
		1, 674, 1, 674, 1, 674, 1, 674, 1, 674, 1, 674, 3, 674, 9774, 8, 674, 1,
		674, 1, 674, 1, 674, 1, 674, 1, 674, 1, 674, 1, 674, 1, 674, 1, 674, 1,
		674, 1, 674, 1, 674, 3, 674, 9788, 8, 674, 1, 674, 1, 674, 1, 674, 3, 674,
		9793, 8, 674, 1, 675, 1, 675, 1, 676, 1, 676, 1, 677, 1, 677, 1, 678, 1,
		678, 1, 679, 1, 679, 1, 679, 1, 680, 1, 680, 1, 680, 1, 680, 5, 680, 9810,
		8, 680, 10, 680, 12, 680, 9813, 9, 680, 1, 680, 1, 680, 3, 680, 9817, 8,
		680, 1, 681, 1, 681, 1, 681, 3, 681, 9822, 8, 681, 1, 682, 1, 682, 1, 682,
		1, 682, 1, 682, 3, 682, 9829, 8, 682, 1, 683, 1, 683, 1, 684, 1, 684, 1,
		684, 3, 684, 9836, 8, 684, 1, 685, 1, 685, 1, 685, 5, 685, 9841, 8, 685,
		10, 685, 12, 685, 9844, 9, 685, 1, 686, 1, 686, 1, 686, 1, 686, 1, 686,
		1, 686, 3, 686, 9852, 8, 686, 1, 687, 1, 687, 1, 687, 1, 687, 3, 687, 9858,
		8, 687, 1, 688, 1, 688, 1, 688, 1, 688, 3, 688, 9864, 8, 688, 1, 689, 1,
		689, 1, 689, 1, 689, 3, 689, 9870, 8, 689, 1, 690, 1, 690, 1, 690, 1, 690,
		1, 690, 1, 690, 3, 690, 9878, 8, 690, 1, 691, 1, 691, 1, 691, 1, 691, 1,
		691, 1, 691, 1, 691, 3, 691, 9887, 8, 691, 1, 692, 1, 692, 1, 693, 1, 693,
		1, 694, 1, 694, 1, 694, 1, 694, 1, 694, 1, 694, 1, 694, 1, 694, 1, 694,
		1, 694, 1, 694, 1, 694, 1, 694, 1, 694, 1, 694, 1, 694, 1, 694, 1, 694,
		1, 694, 1, 694, 1, 694, 1, 694, 1, 694, 1, 694, 1, 694, 1, 694, 1, 694,
		1, 694, 1, 694, 1, 694, 1, 694, 1, 694, 1, 694, 1, 694, 1, 694, 1, 694,
		1, 694, 1, 694, 1, 694, 1, 694, 1, 694, 1, 694, 1, 694, 1, 694, 1, 694,
		1, 694, 1, 694, 1, 694, 1, 694, 1, 694, 1, 694, 1, 694, 3, 694, 9945, 8,
		694, 1, 695, 1, 695, 1, 696, 1, 696, 1, 697, 1, 697, 1, 698, 1, 698, 1,
		698, 1, 698, 1, 699, 5, 699, 9958, 8, 699, 10, 699, 12, 699, 9961, 9, 699,
		1, 700, 1, 700, 1, 700, 1, 700, 1, 700, 1, 700, 1, 700, 1, 700, 1, 700,
		1, 700, 1, 700, 1, 700, 1, 700, 1, 700, 1, 700, 1, 700, 1, 700, 1, 700,
		1, 700, 1, 700, 3, 700, 9983, 8, 700, 1, 701, 1, 701, 1, 702, 1, 702, 1,
		702, 1, 702, 3, 702, 9991, 8, 702, 1, 703, 1, 703, 3, 703, 9995, 8, 703,
		1, 704, 1, 704, 1, 704, 1, 704, 1, 704, 1, 704, 1, 704, 1, 705, 1, 705,
		1, 705, 3, 705, 10007, 8, 705, 3, 705, 10009, 8, 705, 1, 706, 1, 706, 1,
		707, 4, 707, 10014, 8, 707, 11, 707, 12, 707, 10015, 1, 708, 1, 708, 1,
		708, 1, 708, 1, 709, 1, 709, 1, 709, 3, 709, 10025, 8, 709, 1, 710, 1,
		710, 1, 710, 1, 710, 1, 710, 1, 710, 1, 710, 1, 710, 1, 710, 1, 710, 1,
		710, 1, 710, 1, 710, 1, 710, 1, 710, 1, 710, 3, 710, 10043, 8, 710, 1,
		710, 1, 710, 1, 711, 1, 711, 1, 711, 1, 711, 3, 711, 10051, 8, 711, 1,
		712, 1, 712, 1, 713, 1, 713, 1, 713, 1, 713, 1, 713, 3, 713, 10060, 8,
		713, 1, 714, 1, 714, 1, 714, 5, 714, 10065, 8, 714, 10, 714, 12, 714, 10068,
		9, 714, 1, 715, 1, 715, 1, 715, 1, 716, 1, 716, 1, 717, 1, 717, 3, 717,
		10077, 8, 717, 1, 718, 1, 718, 1, 719, 1, 719, 3, 719, 10083, 8, 719, 1,
		720, 1, 720, 1, 721, 1, 721, 1, 721, 3, 721, 10090, 8, 721, 1, 722, 1,
		722, 1, 722, 3, 722, 10095, 8, 722, 1, 723, 1, 723, 1, 723, 1, 723, 3,
		723, 10101, 8, 723, 1, 724, 1, 724, 3, 724, 10105, 8, 724, 1, 725, 1, 725,
		1, 726, 5, 726, 10110, 8, 726, 10, 726, 12, 726, 10113, 9, 726, 1, 727,
		1, 727, 1, 727, 1, 727, 1, 727, 1, 727, 1, 727, 1, 727, 1, 727, 1, 727,
		1, 727, 1, 727, 1, 727, 1, 727, 1, 727, 1, 727, 1, 727, 1, 727, 1, 727,
		1, 727, 1, 727, 1, 727, 1, 727, 1, 727, 1, 727, 1, 727, 1, 727, 3, 727,
		10142, 8, 727, 1, 728, 1, 728, 1, 728, 1, 728, 1, 729, 1, 729, 1, 729,
		1, 729, 1, 729, 1, 729, 1, 729, 1, 729, 1, 729, 1, 729, 1, 729, 1, 729,
		1, 729, 1, 729, 3, 729, 10162, 8, 729, 1, 730, 1, 730, 3, 730, 10166, 8,
		730, 1, 731, 1, 731, 1, 731, 1, 731, 1, 731, 1, 732, 1, 732, 1, 732, 1,
		732, 1, 732, 1, 732, 1, 733, 1, 733, 1, 733, 3, 733, 10182, 8, 733, 1,
		734, 1, 734, 1, 734, 5, 734, 10187, 8, 734, 10, 734, 12, 734, 10190, 9,
		734, 1, 735, 1, 735, 1, 735, 1, 735, 1, 736, 1, 736, 1, 737, 1, 737, 1,
		738, 1, 738, 3, 738, 10202, 8, 738, 1, 738, 1, 738, 1, 738, 1, 738, 5,
		738, 10208, 8, 738, 10, 738, 12, 738, 10211, 9, 738, 1, 739, 1, 739, 1,
		739, 1, 739, 1, 739, 1, 739, 1, 739, 1, 739, 1, 739, 1, 739, 1, 740, 1,
		740, 1, 740, 1, 740, 1, 740, 5, 740, 10228, 8, 740, 10, 740, 12, 740, 10231,
		9, 740, 1, 741, 1, 741, 1, 741, 3, 741, 10236, 8, 741, 1, 742, 1, 742,
		1, 742, 1, 742, 1, 742, 1, 742, 1, 742, 1, 742, 1, 743, 1, 743, 3, 743,
		10248, 8, 743, 1, 744, 4, 744, 10251, 8, 744, 11, 744, 12, 744, 10252,
		1, 745, 1, 745, 1, 745, 1, 745, 1, 745, 1, 746, 1, 746, 1, 746, 3, 746,
		10263, 8, 746, 1, 747, 1, 747, 1, 747, 1, 748, 1, 748, 1, 748, 1, 748,
		1, 748, 1, 749, 1, 749, 1, 749, 1, 749, 1, 749, 1, 750, 1, 750, 1, 750,
		1, 750, 1, 750, 1, 750, 1, 750, 1, 750, 1, 750, 1, 750, 1, 750, 1, 750,
		1, 750, 1, 750, 1, 750, 1, 750, 1, 750, 3, 750, 10295, 8, 750, 1, 751,
		1, 751, 1, 751, 3, 751, 10300, 8, 751, 1, 752, 1, 752, 1, 752, 1, 752,
		1, 752, 5, 752, 10307, 8, 752, 10, 752, 12, 752, 10310, 9, 752, 1, 752,
		1, 752, 3, 752, 10314, 8, 752, 1, 753, 1, 753, 3, 753, 10318, 8, 753, 1,
		754, 1, 754, 1, 754, 3, 754, 10323, 8, 754, 1, 755, 1, 755, 1, 756, 1,
		756, 1, 756, 1, 756, 1, 756, 1, 756, 1, 756, 1, 756, 1, 756, 1, 757, 1,
		757, 1, 757, 3, 757, 10339, 8, 757, 1, 758, 1, 758, 1, 758, 1, 758, 1,
		758, 1, 759, 1, 759, 1, 760, 1, 760, 1, 760, 1, 760, 1, 760, 1, 760, 1,
		760, 1, 760, 1, 760, 3, 760, 10357, 8, 760, 1, 760, 3, 760, 10360, 8, 760,
		1, 760, 1, 760, 1, 761, 1, 761, 3, 761, 10366, 8, 761, 1, 762, 1, 762,
		1, 762, 1, 762, 1, 762, 1, 762, 1, 762, 1, 762, 1, 762, 1, 762, 1, 762,
		1, 762, 1, 762, 1, 762, 1, 762, 1, 762, 1, 762, 1, 762, 1, 762, 1, 762,
		1, 762, 1, 762, 1, 762, 1, 762, 1, 762, 1, 762, 3, 762, 10394, 8, 762,
		1, 763, 1, 763, 1, 763, 1, 763, 1, 763, 1, 763, 1, 763, 1, 763, 3, 763,
		10404, 8, 763, 1, 764, 1, 764, 1, 764, 4, 764, 10409, 8, 764, 11, 764,
		12, 764, 10410, 3, 764, 10413, 8, 764, 1, 765, 1, 765, 1, 765, 3, 765,
		10418, 8, 765, 1, 766, 1, 766, 1, 766, 1, 766, 1, 767, 1, 767, 1, 767,
		5, 767, 10427, 8, 767, 10, 767, 12, 767, 10430, 9, 767, 1, 768, 1, 768,
		1, 768, 1, 768, 1, 768, 1, 769, 1, 769, 1, 769, 3, 769, 10440, 8, 769,
		1, 770, 1, 770, 1, 770, 1, 770, 1, 770, 1, 770, 1, 770, 1, 771, 1, 771,
		1, 771, 1, 772, 1, 772, 1, 772, 1, 772, 1, 772, 1, 772, 1, 772, 1, 772,
		1, 772, 3, 772, 10461, 8, 772, 1, 772, 1, 772, 1, 773, 1, 773, 1, 773,
		3, 773, 10468, 8, 773, 1, 774, 1, 774, 1, 774, 5, 774, 10473, 8, 774, 10,
		774, 12, 774, 10476, 9, 774, 1, 775, 1, 775, 1, 775, 3, 775, 10481, 8,
		775, 1, 775, 3, 775, 10484, 8, 775, 1, 776, 1, 776, 1, 776, 1, 776, 1,
		776, 1, 776, 1, 776, 1, 776, 1, 776, 3, 776, 10495, 8, 776, 1, 776, 1,
		776, 1, 776, 1, 776, 1, 776, 3, 776, 10502, 8, 776, 3, 776, 10504, 8, 776,
		1, 776, 1, 776, 1, 777, 1, 777, 1, 777, 1, 777, 1, 777, 3, 777, 10513,
		8, 777, 1, 778, 1, 778, 1, 778, 5, 778, 10518, 8, 778, 10, 778, 12, 778,
		10521, 9, 778, 1, 779, 1, 779, 1, 779, 3, 779, 10526, 8, 779, 1, 780, 1,
		780, 1, 780, 1, 780, 3, 780, 10532, 8, 780, 1, 781, 1, 781, 3, 781, 10536,
		8, 781, 1, 782, 1, 782, 1, 782, 1, 782, 1, 782, 1, 782, 1, 782, 1, 782,
		1, 783, 1, 783, 1, 784, 1, 784, 1, 784, 3, 784, 10551, 8, 784, 1, 785,
		1, 785, 1, 785, 1, 785, 1, 785, 1, 785, 1, 785, 1, 785, 1, 785, 1, 785,
		1, 785, 1, 785, 1, 785, 1, 785, 1, 785, 3, 785, 10568, 8, 785, 3, 785,
		10570, 8, 785, 1, 786, 1, 786, 1, 786, 1, 786, 1, 786, 1, 787, 1, 787,
		1, 787, 1, 787, 1, 788, 1, 788, 1, 788, 1, 789, 1, 789, 1, 789, 1, 789,
		1, 790, 1, 790, 1, 790, 1, 790, 1, 791, 1, 791, 3, 791, 10594, 8, 791,
		1, 791, 1, 791, 3, 791, 10598, 8, 791, 1, 792, 1, 792, 1, 792, 1, 792,
		1, 792, 1, 792, 1, 792, 1, 792, 1, 792, 3, 792, 10609, 8, 792, 1, 792,
		3, 792, 10612, 8, 792, 1, 793, 1, 793, 3, 793, 10616, 8, 793, 1, 794, 1,
		794, 1, 794, 3, 794, 10621, 8, 794, 1, 795, 4, 795, 10624, 8, 795, 11,
		795, 12, 795, 10625, 1, 796, 1, 796, 1, 796, 1, 796, 1, 796, 1, 797, 1,
		797, 1, 797, 5, 797, 10636, 8, 797, 10, 797, 12, 797, 10639, 9, 797, 1,
		798, 1, 798, 1, 798, 3, 798, 10644, 8, 798, 1, 799, 1, 799, 3, 799, 10648,
		8, 799, 1, 800, 1, 800, 3, 800, 10652, 8, 800, 1, 801, 1, 801, 3, 801,
		10656, 8, 801, 1, 802, 1, 802, 1, 802, 3, 802, 10661, 8, 802, 1, 803, 1,
		803, 3, 803, 10665, 8, 803, 1, 804, 1, 804, 1, 805, 1, 805, 1, 805, 1,
		805, 1, 805, 1, 805, 1, 805, 1, 805, 1, 806, 1, 806, 1, 807, 1, 807, 1,
		808, 1, 808, 1, 809, 1, 809, 1, 810, 1, 810, 1, 810, 1, 811, 1, 811, 1,
		811, 1, 811, 1, 811, 3, 811, 10693, 8, 811, 1, 811, 0, 1, 1204, 812, 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, 0, 69, 2, 0, 195, 195,
		357, 357, 2, 0, 66, 66, 311, 311, 2, 0, 99, 99, 311, 311, 3, 0, 66, 66,
		99, 99, 311, 311, 2, 0, 133, 133, 191, 191, 2, 0, 245, 245, 325, 325, 2,
		0, 10, 10, 94, 94, 2, 0, 162, 162, 356, 356, 2, 0, 180, 180, 221, 221,
		5, 0, 30, 30, 281, 281, 322, 322, 345, 345, 347, 347, 2, 0, 64, 64, 94,
		94, 2, 0, 345, 345, 347, 347, 2, 0, 200, 200, 224, 224, 9, 0, 30, 30, 160,
		160, 165, 165, 179, 179, 219, 219, 227, 227, 335, 335, 338, 338, 438, 438,
		3, 0, 113, 113, 277, 277, 329, 329, 2, 0, 53, 53, 78, 78, 3, 0, 173, 173,
		252, 252, 255, 255, 5, 0, 30, 30, 88, 88, 182, 182, 232, 232, 362, 362,
		2, 0, 92, 92, 226, 226, 1, 0, 448, 449, 2, 0, 92, 92, 407, 407, 2, 0, 334,
		334, 407, 407, 2, 0, 211, 211, 289, 289, 3, 0, 314, 314, 350, 350, 445,
		445, 2, 0, 64, 64, 68, 68, 5, 0, 212, 212, 322, 322, 343, 343, 354, 354,
		455, 456, 2, 0, 10, 10, 53, 53, 3, 0, 211, 211, 289, 289, 442, 442, 5,
		0, 92, 92, 175, 175, 226, 226, 316, 316, 342, 342, 3, 0, 175, 175, 316,
		316, 342, 342, 3, 0, 109, 109, 128, 128, 344, 344, 4, 0, 88, 88, 182, 182,
		232, 232, 362, 362, 2, 0, 151, 151, 245, 245, 2, 0, 306, 306, 326, 326,
		1, 0, 31, 32, 2, 0, 99, 99, 342, 342, 2, 0, 201, 201, 327, 327, 2, 0, 59,
		59, 97, 97, 2, 0, 213, 213, 245, 245, 2, 0, 313, 313, 407, 407, 2, 0, 207,
		207, 261, 261, 4, 0, 113, 113, 115, 115, 119, 119, 126, 126, 2, 0, 353,
		353, 477, 477, 2, 0, 384, 385, 399, 399, 1, 0, 384, 385, 1, 0, 411, 412,
		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, 2, 0, 30, 30, 56,
		56, 3, 0, 39, 39, 73, 73, 95, 95, 2, 0, 166, 166, 188, 188, 2, 0, 297,
		297, 450, 450, 2, 0, 208, 208, 282, 282, 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, 11, 0, 124, 124, 129, 249, 251, 252, 254, 303, 305,
		379, 433, 452, 455, 469, 471, 471, 473, 473, 475, 475, 478, 488, 5, 0,
		106, 118, 120, 123, 125, 125, 127, 128, 472, 472, 4, 0, 30, 52, 54, 70,
		72, 105, 454, 454, 5, 0, 304, 304, 418, 424, 504, 504, 513, 513, 521, 635,
		2, 0, 62, 62, 116, 116, 2, 0, 10, 10, 20, 20, 2, 0, 167, 167, 507, 507,
		2, 0, 144, 144, 210, 210, 36, 0, 33, 33, 35, 35, 43, 45, 53, 53, 57, 57,
		61, 61, 92, 92, 116, 116, 123, 123, 130, 130, 144, 144, 153, 153, 157,
		157, 161, 161, 167, 167, 172, 172, 207, 207, 210, 210, 232, 232, 240, 240,
		258, 258, 261, 262, 272, 272, 286, 286, 300, 300, 306, 306, 312, 312, 316,
		317, 326, 326, 353, 353, 433, 434, 477, 477, 490, 502, 506, 512, 514, 518,
		520, 520, 11556, 0, 1624, 1, 0, 0, 0, 2, 1627, 1, 0, 0, 0, 4, 1629, 1,
		0, 0, 0, 6, 1637, 1, 0, 0, 0, 8, 1765, 1, 0, 0, 0, 10, 1767, 1, 0, 0, 0,
		12, 1771, 1, 0, 0, 0, 14, 1774, 1, 0, 0, 0, 16, 1782, 1, 0, 0, 0, 18, 1787,
		1, 0, 0, 0, 20, 1793, 1, 0, 0, 0, 22, 1814, 1, 0, 0, 0, 24, 1826, 1, 0,
		0, 0, 26, 1828, 1, 0, 0, 0, 28, 1834, 1, 0, 0, 0, 30, 1844, 1, 0, 0, 0,
		32, 1846, 1, 0, 0, 0, 34, 1855, 1, 0, 0, 0, 36, 1863, 1, 0, 0, 0, 38, 1869,
		1, 0, 0, 0, 40, 1876, 1, 0, 0, 0, 42, 1878, 1, 0, 0, 0, 44, 1896, 1, 0,
		0, 0, 46, 1901, 1, 0, 0, 0, 48, 1910, 1, 0, 0, 0, 50, 1912, 1, 0, 0, 0,
		52, 1926, 1, 0, 0, 0, 54, 1928, 1, 0, 0, 0, 56, 1957, 1, 0, 0, 0, 58, 1959,
		1, 0, 0, 0, 60, 1967, 1, 0, 0, 0, 62, 1977, 1, 0, 0, 0, 64, 1984, 1, 0,
		0, 0, 66, 1990, 1, 0, 0, 0, 68, 2007, 1, 0, 0, 0, 70, 2012, 1, 0, 0, 0,
		72, 2016, 1, 0, 0, 0, 74, 2018, 1, 0, 0, 0, 76, 2029, 1, 0, 0, 0, 78, 2033,
		1, 0, 0, 0, 80, 2038, 1, 0, 0, 0, 82, 2043, 1, 0, 0, 0, 84, 2045, 1, 0,
		0, 0, 86, 2057, 1, 0, 0, 0, 88, 2064, 1, 0, 0, 0, 90, 2066, 1, 0, 0, 0,
		92, 2068, 1, 0, 0, 0, 94, 2070, 1, 0, 0, 0, 96, 2182, 1, 0, 0, 0, 98, 2184,
		1, 0, 0, 0, 100, 2200, 1, 0, 0, 0, 102, 2202, 1, 0, 0, 0, 104, 2458, 1,
		0, 0, 0, 106, 2465, 1, 0, 0, 0, 108, 2470, 1, 0, 0, 0, 110, 2475, 1, 0,
		0, 0, 112, 2480, 1, 0, 0, 0, 114, 2488, 1, 0, 0, 0, 116, 2490, 1, 0, 0,
		0, 118, 2497, 1, 0, 0, 0, 120, 2499, 1, 0, 0, 0, 122, 2507, 1, 0, 0, 0,
		124, 2519, 1, 0, 0, 0, 126, 2535, 1, 0, 0, 0, 128, 2563, 1, 0, 0, 0, 130,
		2565, 1, 0, 0, 0, 132, 2568, 1, 0, 0, 0, 134, 2576, 1, 0, 0, 0, 136, 2581,
		1, 0, 0, 0, 138, 2612, 1, 0, 0, 0, 140, 2614, 1, 0, 0, 0, 142, 2641, 1,
		0, 0, 0, 144, 2643, 1, 0, 0, 0, 146, 2647, 1, 0, 0, 0, 148, 2652, 1, 0,
		0, 0, 150, 2659, 1, 0, 0, 0, 152, 2664, 1, 0, 0, 0, 154, 2702, 1, 0, 0,
		0, 156, 2706, 1, 0, 0, 0, 158, 2713, 1, 0, 0, 0, 160, 2717, 1, 0, 0, 0,
		162, 2719, 1, 0, 0, 0, 164, 2727, 1, 0, 0, 0, 166, 2738, 1, 0, 0, 0, 168,
		2740, 1, 0, 0, 0, 170, 2748, 1, 0, 0, 0, 172, 2750, 1, 0, 0, 0, 174, 2799,
		1, 0, 0, 0, 176, 2803, 1, 0, 0, 0, 178, 2810, 1, 0, 0, 0, 180, 2812, 1,
		0, 0, 0, 182, 2820, 1, 0, 0, 0, 184, 2831, 1, 0, 0, 0, 186, 2835, 1, 0,
		0, 0, 188, 2837, 1, 0, 0, 0, 190, 2842, 1, 0, 0, 0, 192, 2852, 1, 0, 0,
		0, 194, 2863, 1, 0, 0, 0, 196, 2903, 1, 0, 0, 0, 198, 2908, 1, 0, 0, 0,
		200, 2915, 1, 0, 0, 0, 202, 2917, 1, 0, 0, 0, 204, 2925, 1, 0, 0, 0, 206,
		2928, 1, 0, 0, 0, 208, 2935, 1, 0, 0, 0, 210, 2995, 1, 0, 0, 0, 212, 3000,
		1, 0, 0, 0, 214, 3007, 1, 0, 0, 0, 216, 3009, 1, 0, 0, 0, 218, 3017, 1,
		0, 0, 0, 220, 3025, 1, 0, 0, 0, 222, 3030, 1, 0, 0, 0, 224, 3032, 1, 0,
		0, 0, 226, 3040, 1, 0, 0, 0, 228, 3056, 1, 0, 0, 0, 230, 3067, 1, 0, 0,
		0, 232, 3069, 1, 0, 0, 0, 234, 3073, 1, 0, 0, 0, 236, 3083, 1, 0, 0, 0,
		238, 3091, 1, 0, 0, 0, 240, 3095, 1, 0, 0, 0, 242, 3097, 1, 0, 0, 0, 244,
		3104, 1, 0, 0, 0, 246, 3126, 1, 0, 0, 0, 248, 3131, 1, 0, 0, 0, 250, 3138,
		1, 0, 0, 0, 252, 3150, 1, 0, 0, 0, 254, 3155, 1, 0, 0, 0, 256, 3162, 1,
		0, 0, 0, 258, 3164, 1, 0, 0, 0, 260, 3168, 1, 0, 0, 0, 262, 3182, 1, 0,
		0, 0, 264, 3193, 1, 0, 0, 0, 266, 3206, 1, 0, 0, 0, 268, 3220, 1, 0, 0,
		0, 270, 3222, 1, 0, 0, 0, 272, 3236, 1, 0, 0, 0, 274, 3244, 1, 0, 0, 0,
		276, 3246, 1, 0, 0, 0, 278, 3253, 1, 0, 0, 0, 280, 3264, 1, 0, 0, 0, 282,
		3275, 1, 0, 0, 0, 284, 3282, 1, 0, 0, 0, 286, 3285, 1, 0, 0, 0, 288, 3319,
		1, 0, 0, 0, 290, 3323, 1, 0, 0, 0, 292, 3331, 1, 0, 0, 0, 294, 3333, 1,
		0, 0, 0, 296, 3341, 1, 0, 0, 0, 298, 3356, 1, 0, 0, 0, 300, 3358, 1, 0,
		0, 0, 302, 3365, 1, 0, 0, 0, 304, 3371, 1, 0, 0, 0, 306, 3375, 1, 0, 0,
		0, 308, 3379, 1, 0, 0, 0, 310, 3381, 1, 0, 0, 0, 312, 3392, 1, 0, 0, 0,
		314, 3394, 1, 0, 0, 0, 316, 3402, 1, 0, 0, 0, 318, 3416, 1, 0, 0, 0, 320,
		3426, 1, 0, 0, 0, 322, 3428, 1, 0, 0, 0, 324, 3437, 1, 0, 0, 0, 326, 3440,
		1, 0, 0, 0, 328, 3547, 1, 0, 0, 0, 330, 3549, 1, 0, 0, 0, 332, 3565, 1,
		0, 0, 0, 334, 3568, 1, 0, 0, 0, 336, 3574, 1, 0, 0, 0, 338, 3591, 1, 0,
		0, 0, 340, 3599, 1, 0, 0, 0, 342, 3601, 1, 0, 0, 0, 344, 3609, 1, 0, 0,
		0, 346, 3614, 1, 0, 0, 0, 348, 3629, 1, 0, 0, 0, 350, 3631, 1, 0, 0, 0,
		352, 3634, 1, 0, 0, 0, 354, 3636, 1, 0, 0, 0, 356, 3663, 1, 0, 0, 0, 358,
		3668, 1, 0, 0, 0, 360, 3670, 1, 0, 0, 0, 362, 3677, 1, 0, 0, 0, 364, 3679,
		1, 0, 0, 0, 366, 3745, 1, 0, 0, 0, 368, 3747, 1, 0, 0, 0, 370, 3762, 1,
		0, 0, 0, 372, 3770, 1, 0, 0, 0, 374, 3793, 1, 0, 0, 0, 376, 3797, 1, 0,
		0, 0, 378, 3817, 1, 0, 0, 0, 380, 3819, 1, 0, 0, 0, 382, 3828, 1, 0, 0,
		0, 384, 3839, 1, 0, 0, 0, 386, 3854, 1, 0, 0, 0, 388, 3863, 1, 0, 0, 0,
		390, 3868, 1, 0, 0, 0, 392, 3873, 1, 0, 0, 0, 394, 3878, 1, 0, 0, 0, 396,
		3883, 1, 0, 0, 0, 398, 3885, 1, 0, 0, 0, 400, 3887, 1, 0, 0, 0, 402, 3896,
		1, 0, 0, 0, 404, 3936, 1, 0, 0, 0, 406, 3942, 1, 0, 0, 0, 408, 3944, 1,
		0, 0, 0, 410, 3959, 1, 0, 0, 0, 412, 3964, 1, 0, 0, 0, 414, 3967, 1, 0,
		0, 0, 416, 3971, 1, 0, 0, 0, 418, 3976, 1, 0, 0, 0, 420, 3978, 1, 0, 0,
		0, 422, 3980, 1, 0, 0, 0, 424, 3987, 1, 0, 0, 0, 426, 3991, 1, 0, 0, 0,
		428, 3993, 1, 0, 0, 0, 430, 4001, 1, 0, 0, 0, 432, 4003, 1, 0, 0, 0, 434,
		4007, 1, 0, 0, 0, 436, 4020, 1, 0, 0, 0, 438, 4025, 1, 0, 0, 0, 440, 4030,
		1, 0, 0, 0, 442, 4044, 1, 0, 0, 0, 444, 4072, 1, 0, 0, 0, 446, 4074, 1,
		0, 0, 0, 448, 4082, 1, 0, 0, 0, 450, 4088, 1, 0, 0, 0, 452, 4096, 1, 0,
		0, 0, 454, 4108, 1, 0, 0, 0, 456, 4110, 1, 0, 0, 0, 458, 4225, 1, 0, 0,
		0, 460, 4227, 1, 0, 0, 0, 462, 4231, 1, 0, 0, 0, 464, 4239, 1, 0, 0, 0,
		466, 4250, 1, 0, 0, 0, 468, 4252, 1, 0, 0, 0, 470, 4256, 1, 0, 0, 0, 472,
		4264, 1, 0, 0, 0, 474, 4270, 1, 0, 0, 0, 476, 4272, 1, 0, 0, 0, 478, 4317,
		1, 0, 0, 0, 480, 4323, 1, 0, 0, 0, 482, 4325, 1, 0, 0, 0, 484, 4339, 1,
		0, 0, 0, 486, 4372, 1, 0, 0, 0, 488, 4376, 1, 0, 0, 0, 490, 4381, 1, 0,
		0, 0, 492, 4390, 1, 0, 0, 0, 494, 4394, 1, 0, 0, 0, 496, 4396, 1, 0, 0,
		0, 498, 4421, 1, 0, 0, 0, 500, 4423, 1, 0, 0, 0, 502, 4443, 1, 0, 0, 0,
		504, 4463, 1, 0, 0, 0, 506, 4483, 1, 0, 0, 0, 508, 4485, 1, 0, 0, 0, 510,
		4491, 1, 0, 0, 0, 512, 4576, 1, 0, 0, 0, 514, 4601, 1, 0, 0, 0, 516, 4608,
		1, 0, 0, 0, 518, 4624, 1, 0, 0, 0, 520, 4626, 1, 0, 0, 0, 522, 4628, 1,
		0, 0, 0, 524, 4636, 1, 0, 0, 0, 526, 4642, 1, 0, 0, 0, 528, 4646, 1, 0,
		0, 0, 530, 4654, 1, 0, 0, 0, 532, 4665, 1, 0, 0, 0, 534, 4814, 1, 0, 0,
		0, 536, 4818, 1, 0, 0, 0, 538, 4911, 1, 0, 0, 0, 540, 4916, 1, 0, 0, 0,
		542, 4920, 1, 0, 0, 0, 544, 4926, 1, 0, 0, 0, 546, 4994, 1, 0, 0, 0, 548,
		4996, 1, 0, 0, 0, 550, 5000, 1, 0, 0, 0, 552, 5002, 1, 0, 0, 0, 554, 5029,
		1, 0, 0, 0, 556, 5046, 1, 0, 0, 0, 558, 5048, 1, 0, 0, 0, 560, 5065, 1,
		0, 0, 0, 562, 5125, 1, 0, 0, 0, 564, 5127, 1, 0, 0, 0, 566, 5138, 1, 0,
		0, 0, 568, 5144, 1, 0, 0, 0, 570, 5146, 1, 0, 0, 0, 572, 5170, 1, 0, 0,
		0, 574, 5176, 1, 0, 0, 0, 576, 5182, 1, 0, 0, 0, 578, 5184, 1, 0, 0, 0,
		580, 5193, 1, 0, 0, 0, 582, 5205, 1, 0, 0, 0, 584, 5234, 1, 0, 0, 0, 586,
		5236, 1, 0, 0, 0, 588, 5273, 1, 0, 0, 0, 590, 5277, 1, 0, 0, 0, 592, 5281,
		1, 0, 0, 0, 594, 5285, 1, 0, 0, 0, 596, 5290, 1, 0, 0, 0, 598, 5292, 1,
		0, 0, 0, 600, 5311, 1, 0, 0, 0, 602, 5324, 1, 0, 0, 0, 604, 5332, 1, 0,
		0, 0, 606, 5334, 1, 0, 0, 0, 608, 5345, 1, 0, 0, 0, 610, 5349, 1, 0, 0,
		0, 612, 5354, 1, 0, 0, 0, 614, 5361, 1, 0, 0, 0, 616, 5363, 1, 0, 0, 0,
		618, 5384, 1, 0, 0, 0, 620, 5386, 1, 0, 0, 0, 622, 5392, 1, 0, 0, 0, 624,
		5400, 1, 0, 0, 0, 626, 5416, 1, 0, 0, 0, 628, 5418, 1, 0, 0, 0, 630, 5424,
		1, 0, 0, 0, 632, 5445, 1, 0, 0, 0, 634, 5454, 1, 0, 0, 0, 636, 5460, 1,
		0, 0, 0, 638, 5462, 1, 0, 0, 0, 640, 5478, 1, 0, 0, 0, 642, 5480, 1, 0,
		0, 0, 644, 5485, 1, 0, 0, 0, 646, 5487, 1, 0, 0, 0, 648, 5502, 1, 0, 0,
		0, 650, 5510, 1, 0, 0, 0, 652, 5513, 1, 0, 0, 0, 654, 5522, 1, 0, 0, 0,
		656, 5563, 1, 0, 0, 0, 658, 5573, 1, 0, 0, 0, 660, 5580, 1, 0, 0, 0, 662,
		5582, 1, 0, 0, 0, 664, 5597, 1, 0, 0, 0, 666, 5599, 1, 0, 0, 0, 668, 5602,
		1, 0, 0, 0, 670, 5610, 1, 0, 0, 0, 672, 5617, 1, 0, 0, 0, 674, 5623, 1,
		0, 0, 0, 676, 5661, 1, 0, 0, 0, 678, 5675, 1, 0, 0, 0, 680, 5689, 1, 0,
		0, 0, 682, 5713, 1, 0, 0, 0, 684, 5720, 1, 0, 0, 0, 686, 5725, 1, 0, 0,
		0, 688, 5733, 1, 0, 0, 0, 690, 5736, 1, 0, 0, 0, 692, 5740, 1, 0, 0, 0,
		694, 5747, 1, 0, 0, 0, 696, 5783, 1, 0, 0, 0, 698, 5790, 1, 0, 0, 0, 700,
		5792, 1, 0, 0, 0, 702, 5805, 1, 0, 0, 0, 704, 5807, 1, 0, 0, 0, 706, 5852,
		1, 0, 0, 0, 708, 5854, 1, 0, 0, 0, 710, 5889, 1, 0, 0, 0, 712, 5891, 1,
		0, 0, 0, 714, 5893, 1, 0, 0, 0, 716, 5895, 1, 0, 0, 0, 718, 5903, 1, 0,
		0, 0, 720, 5917, 1, 0, 0, 0, 722, 6387, 1, 0, 0, 0, 724, 6391, 1, 0, 0,
		0, 726, 6396, 1, 0, 0, 0, 728, 6455, 1, 0, 0, 0, 730, 6459, 1, 0, 0, 0,
		732, 6678, 1, 0, 0, 0, 734, 6680, 1, 0, 0, 0, 736, 6688, 1, 0, 0, 0, 738,
		6704, 1, 0, 0, 0, 740, 6711, 1, 0, 0, 0, 742, 6713, 1, 0, 0, 0, 744, 6904,
		1, 0, 0, 0, 746, 6906, 1, 0, 0, 0, 748, 6914, 1, 0, 0, 0, 750, 6922, 1,
		0, 0, 0, 752, 6951, 1, 0, 0, 0, 754, 6953, 1, 0, 0, 0, 756, 6962, 1, 0,
		0, 0, 758, 6970, 1, 0, 0, 0, 760, 7009, 1, 0, 0, 0, 762, 7023, 1, 0, 0,
		0, 764, 7025, 1, 0, 0, 0, 766, 7045, 1, 0, 0, 0, 768, 7047, 1, 0, 0, 0,
		770, 7060, 1, 0, 0, 0, 772, 7064, 1, 0, 0, 0, 774, 7066, 1, 0, 0, 0, 776,
		7071, 1, 0, 0, 0, 778, 7073, 1, 0, 0, 0, 780, 7080, 1, 0, 0, 0, 782, 7082,
		1, 0, 0, 0, 784, 7089, 1, 0, 0, 0, 786, 7141, 1, 0, 0, 0, 788, 7146, 1,
		0, 0, 0, 790, 7158, 1, 0, 0, 0, 792, 7160, 1, 0, 0, 0, 794, 7172, 1, 0,
		0, 0, 796, 7180, 1, 0, 0, 0, 798, 7182, 1, 0, 0, 0, 800, 7214, 1, 0, 0,
		0, 802, 7216, 1, 0, 0, 0, 804, 7219, 1, 0, 0, 0, 806, 7227, 1, 0, 0, 0,
		808, 7230, 1, 0, 0, 0, 810, 7234, 1, 0, 0, 0, 812, 7249, 1, 0, 0, 0, 814,
		7253, 1, 0, 0, 0, 816, 7255, 1, 0, 0, 0, 818, 7266, 1, 0, 0, 0, 820, 7271,
		1, 0, 0, 0, 822, 7285, 1, 0, 0, 0, 824, 7293, 1, 0, 0, 0, 826, 7295, 1,
		0, 0, 0, 828, 7301, 1, 0, 0, 0, 830, 7306, 1, 0, 0, 0, 832, 7313, 1, 0,
		0, 0, 834, 7341, 1, 0, 0, 0, 836, 7343, 1, 0, 0, 0, 838, 7422, 1, 0, 0,
		0, 840, 7424, 1, 0, 0, 0, 842, 7426, 1, 0, 0, 0, 844, 7450, 1, 0, 0, 0,
		846, 7455, 1, 0, 0, 0, 848, 7470, 1, 0, 0, 0, 850, 7482, 1, 0, 0, 0, 852,
		7484, 1, 0, 0, 0, 854, 7492, 1, 0, 0, 0, 856, 7494, 1, 0, 0, 0, 858, 7499,
		1, 0, 0, 0, 860, 7504, 1, 0, 0, 0, 862, 7508, 1, 0, 0, 0, 864, 7512, 1,
		0, 0, 0, 866, 7516, 1, 0, 0, 0, 868, 7520, 1, 0, 0, 0, 870, 7527, 1, 0,
		0, 0, 872, 7529, 1, 0, 0, 0, 874, 7532, 1, 0, 0, 0, 876, 7542, 1, 0, 0,
		0, 878, 7560, 1, 0, 0, 0, 880, 7571, 1, 0, 0, 0, 882, 7573, 1, 0, 0, 0,
		884, 7581, 1, 0, 0, 0, 886, 7586, 1, 0, 0, 0, 888, 7591, 1, 0, 0, 0, 890,
		7593, 1, 0, 0, 0, 892, 7604, 1, 0, 0, 0, 894, 7610, 1, 0, 0, 0, 896, 7639,
		1, 0, 0, 0, 898, 7646, 1, 0, 0, 0, 900, 7658, 1, 0, 0, 0, 902, 7660, 1,
		0, 0, 0, 904, 7668, 1, 0, 0, 0, 906, 7692, 1, 0, 0, 0, 908, 7694, 1, 0,
		0, 0, 910, 7696, 1, 0, 0, 0, 912, 7704, 1, 0, 0, 0, 914, 7720, 1, 0, 0,
		0, 916, 7731, 1, 0, 0, 0, 918, 7736, 1, 0, 0, 0, 920, 7738, 1, 0, 0, 0,
		922, 7769, 1, 0, 0, 0, 924, 7788, 1, 0, 0, 0, 926, 7801, 1, 0, 0, 0, 928,
		7808, 1, 0, 0, 0, 930, 7819, 1, 0, 0, 0, 932, 7821, 1, 0, 0, 0, 934, 7832,
		1, 0, 0, 0, 936, 7846, 1, 0, 0, 0, 938, 7850, 1, 0, 0, 0, 940, 7856, 1,
		0, 0, 0, 942, 7858, 1, 0, 0, 0, 944, 7867, 1, 0, 0, 0, 946, 7885, 1, 0,
		0, 0, 948, 7887, 1, 0, 0, 0, 950, 7890, 1, 0, 0, 0, 952, 7898, 1, 0, 0,
		0, 954, 7906, 1, 0, 0, 0, 956, 7915, 1, 0, 0, 0, 958, 7923, 1, 0, 0, 0,
		960, 7927, 1, 0, 0, 0, 962, 7937, 1, 0, 0, 0, 964, 7960, 1, 0, 0, 0, 966,
		7962, 1, 0, 0, 0, 968, 7972, 1, 0, 0, 0, 970, 8003, 1, 0, 0, 0, 972, 8005,
		1, 0, 0, 0, 974, 8011, 1, 0, 0, 0, 976, 8019, 1, 0, 0, 0, 978, 8031, 1,
		0, 0, 0, 980, 8035, 1, 0, 0, 0, 982, 8045, 1, 0, 0, 0, 984, 8049, 1, 0,
		0, 0, 986, 8065, 1, 0, 0, 0, 988, 8069, 1, 0, 0, 0, 990, 8074, 1, 0, 0,
		0, 992, 8076, 1, 0, 0, 0, 994, 8086, 1, 0, 0, 0, 996, 8090, 1, 0, 0, 0,
		998, 8092, 1, 0, 0, 0, 1000, 8096, 1, 0, 0, 0, 1002, 8104, 1, 0, 0, 0,
		1004, 8120, 1, 0, 0, 0, 1006, 8124, 1, 0, 0, 0, 1008, 8149, 1, 0, 0, 0,
		1010, 8151, 1, 0, 0, 0, 1012, 8160, 1, 0, 0, 0, 1014, 8162, 1, 0, 0, 0,
		1016, 8169, 1, 0, 0, 0, 1018, 8173, 1, 0, 0, 0, 1020, 8175, 1, 0, 0, 0,
		1022, 8177, 1, 0, 0, 0, 1024, 8183, 1, 0, 0, 0, 1026, 8185, 1, 0, 0, 0,
		1028, 8198, 1, 0, 0, 0, 1030, 8200, 1, 0, 0, 0, 1032, 8203, 1, 0, 0, 0,
		1034, 8208, 1, 0, 0, 0, 1036, 8213, 1, 0, 0, 0, 1038, 8222, 1, 0, 0, 0,
		1040, 8228, 1, 0, 0, 0, 1042, 8232, 1, 0, 0, 0, 1044, 8235, 1, 0, 0, 0,
		1046, 8239, 1, 0, 0, 0, 1048, 8243, 1, 0, 0, 0, 1050, 8258, 1, 0, 0, 0,
		1052, 8260, 1, 0, 0, 0, 1054, 8277, 1, 0, 0, 0, 1056, 8288, 1, 0, 0, 0,
		1058, 8290, 1, 0, 0, 0, 1060, 8346, 1, 0, 0, 0, 1062, 8370, 1, 0, 0, 0,
		1064, 8381, 1, 0, 0, 0, 1066, 8384, 1, 0, 0, 0, 1068, 8406, 1, 0, 0, 0,
		1070, 8408, 1, 0, 0, 0, 1072, 8419, 1, 0, 0, 0, 1074, 8433, 1, 0, 0, 0,
		1076, 8435, 1, 0, 0, 0, 1078, 8443, 1, 0, 0, 0, 1080, 8450, 1, 0, 0, 0,
		1082, 8463, 1, 0, 0, 0, 1084, 8475, 1, 0, 0, 0, 1086, 8477, 1, 0, 0, 0,
		1088, 8480, 1, 0, 0, 0, 1090, 8494, 1, 0, 0, 0, 1092, 8499, 1, 0, 0, 0,
		1094, 8504, 1, 0, 0, 0, 1096, 8514, 1, 0, 0, 0, 1098, 8518, 1, 0, 0, 0,
		1100, 8520, 1, 0, 0, 0, 1102, 8528, 1, 0, 0, 0, 1104, 8532, 1, 0, 0, 0,
		1106, 8553, 1, 0, 0, 0, 1108, 8561, 1, 0, 0, 0, 1110, 8571, 1, 0, 0, 0,
		1112, 8583, 1, 0, 0, 0, 1114, 8585, 1, 0, 0, 0, 1116, 8599, 1, 0, 0, 0,
		1118, 8619, 1, 0, 0, 0, 1120, 8628, 1, 0, 0, 0, 1122, 8644, 1, 0, 0, 0,
		1124, 8650, 1, 0, 0, 0, 1126, 8656, 1, 0, 0, 0, 1128, 8668, 1, 0, 0, 0,
		1130, 8686, 1, 0, 0, 0, 1132, 8693, 1, 0, 0, 0, 1134, 8697, 1, 0, 0, 0,
		1136, 8701, 1, 0, 0, 0, 1138, 8703, 1, 0, 0, 0, 1140, 8709, 1, 0, 0, 0,
		1142, 8712, 1, 0, 0, 0, 1144, 8719, 1, 0, 0, 0, 1146, 8732, 1, 0, 0, 0,
		1148, 8736, 1, 0, 0, 0, 1150, 8738, 1, 0, 0, 0, 1152, 8747, 1, 0, 0, 0,
		1154, 8756, 1, 0, 0, 0, 1156, 8784, 1, 0, 0, 0, 1158, 8786, 1, 0, 0, 0,
		1160, 8796, 1, 0, 0, 0, 1162, 8798, 1, 0, 0, 0, 1164, 8800, 1, 0, 0, 0,
		1166, 8804, 1, 0, 0, 0, 1168, 8812, 1, 0, 0, 0, 1170, 8820, 1, 0, 0, 0,
		1172, 8828, 1, 0, 0, 0, 1174, 8842, 1, 0, 0, 0, 1176, 8851, 1, 0, 0, 0,
		1178, 8855, 1, 0, 0, 0, 1180, 8859, 1, 0, 0, 0, 1182, 8885, 1, 0, 0, 0,
		1184, 8899, 1, 0, 0, 0, 1186, 8914, 1, 0, 0, 0, 1188, 8924, 1, 0, 0, 0,
		1190, 8928, 1, 0, 0, 0, 1192, 8936, 1, 0, 0, 0, 1194, 8944, 1, 0, 0, 0,
		1196, 8950, 1, 0, 0, 0, 1198, 8954, 1, 0, 0, 0, 1200, 8961, 1, 0, 0, 0,
		1202, 8966, 1, 0, 0, 0, 1204, 8981, 1, 0, 0, 0, 1206, 9061, 1, 0, 0, 0,
		1208, 9063, 1, 0, 0, 0, 1210, 9065, 1, 0, 0, 0, 1212, 9095, 1, 0, 0, 0,
		1214, 9099, 1, 0, 0, 0, 1216, 9278, 1, 0, 0, 0, 1218, 9285, 1, 0, 0, 0,
		1220, 9298, 1, 0, 0, 0, 1222, 9300, 1, 0, 0, 0, 1224, 9305, 1, 0, 0, 0,
		1226, 9313, 1, 0, 0, 0, 1228, 9318, 1, 0, 0, 0, 1230, 9325, 1, 0, 0, 0,
		1232, 9342, 1, 0, 0, 0, 1234, 9344, 1, 0, 0, 0, 1236, 9354, 1, 0, 0, 0,
		1238, 9363, 1, 0, 0, 0, 1240, 9368, 1, 0, 0, 0, 1242, 9370, 1, 0, 0, 0,
		1244, 9378, 1, 0, 0, 0, 1246, 9388, 1, 0, 0, 0, 1248, 9390, 1, 0, 0, 0,
		1250, 9399, 1, 0, 0, 0, 1252, 9405, 1, 0, 0, 0, 1254, 9420, 1, 0, 0, 0,
		1256, 9428, 1, 0, 0, 0, 1258, 9437, 1, 0, 0, 0, 1260, 9449, 1, 0, 0, 0,
		1262, 9463, 1, 0, 0, 0, 1264, 9465, 1, 0, 0, 0, 1266, 9472, 1, 0, 0, 0,
		1268, 9478, 1, 0, 0, 0, 1270, 9482, 1, 0, 0, 0, 1272, 9484, 1, 0, 0, 0,
		1274, 9492, 1, 0, 0, 0, 1276, 9500, 1, 0, 0, 0, 1278, 9514, 1, 0, 0, 0,
		1280, 9516, 1, 0, 0, 0, 1282, 9524, 1, 0, 0, 0, 1284, 9537, 1, 0, 0, 0,
		1286, 9539, 1, 0, 0, 0, 1288, 9547, 1, 0, 0, 0, 1290, 9554, 1, 0, 0, 0,
		1292, 9567, 1, 0, 0, 0, 1294, 9577, 1, 0, 0, 0, 1296, 9579, 1, 0, 0, 0,
		1298, 9581, 1, 0, 0, 0, 1300, 9595, 1, 0, 0, 0, 1302, 9624, 1, 0, 0, 0,
		1304, 9633, 1, 0, 0, 0, 1306, 9640, 1, 0, 0, 0, 1308, 9642, 1, 0, 0, 0,
		1310, 9649, 1, 0, 0, 0, 1312, 9653, 1, 0, 0, 0, 1314, 9661, 1, 0, 0, 0,
		1316, 9665, 1, 0, 0, 0, 1318, 9667, 1, 0, 0, 0, 1320, 9686, 1, 0, 0, 0,
		1322, 9690, 1, 0, 0, 0, 1324, 9693, 1, 0, 0, 0, 1326, 9700, 1, 0, 0, 0,
		1328, 9705, 1, 0, 0, 0, 1330, 9707, 1, 0, 0, 0, 1332, 9723, 1, 0, 0, 0,
		1334, 9725, 1, 0, 0, 0, 1336, 9733, 1, 0, 0, 0, 1338, 9737, 1, 0, 0, 0,
		1340, 9745, 1, 0, 0, 0, 1342, 9747, 1, 0, 0, 0, 1344, 9749, 1, 0, 0, 0,
		1346, 9758, 1, 0, 0, 0, 1348, 9792, 1, 0, 0, 0, 1350, 9794, 1, 0, 0, 0,
		1352, 9796, 1, 0, 0, 0, 1354, 9798, 1, 0, 0, 0, 1356, 9800, 1, 0, 0, 0,
		1358, 9802, 1, 0, 0, 0, 1360, 9816, 1, 0, 0, 0, 1362, 9821, 1, 0, 0, 0,
		1364, 9828, 1, 0, 0, 0, 1366, 9830, 1, 0, 0, 0, 1368, 9835, 1, 0, 0, 0,
		1370, 9837, 1, 0, 0, 0, 1372, 9851, 1, 0, 0, 0, 1374, 9857, 1, 0, 0, 0,
		1376, 9863, 1, 0, 0, 0, 1378, 9869, 1, 0, 0, 0, 1380, 9877, 1, 0, 0, 0,
		1382, 9886, 1, 0, 0, 0, 1384, 9888, 1, 0, 0, 0, 1386, 9890, 1, 0, 0, 0,
		1388, 9944, 1, 0, 0, 0, 1390, 9946, 1, 0, 0, 0, 1392, 9948, 1, 0, 0, 0,
		1394, 9950, 1, 0, 0, 0, 1396, 9952, 1, 0, 0, 0, 1398, 9959, 1, 0, 0, 0,
		1400, 9982, 1, 0, 0, 0, 1402, 9984, 1, 0, 0, 0, 1404, 9990, 1, 0, 0, 0,
		1406, 9994, 1, 0, 0, 0, 1408, 9996, 1, 0, 0, 0, 1410, 10003, 1, 0, 0, 0,
		1412, 10010, 1, 0, 0, 0, 1414, 10013, 1, 0, 0, 0, 1416, 10017, 1, 0, 0,
		0, 1418, 10024, 1, 0, 0, 0, 1420, 10026, 1, 0, 0, 0, 1422, 10050, 1, 0,
		0, 0, 1424, 10052, 1, 0, 0, 0, 1426, 10059, 1, 0, 0, 0, 1428, 10061, 1,
		0, 0, 0, 1430, 10069, 1, 0, 0, 0, 1432, 10072, 1, 0, 0, 0, 1434, 10076,
		1, 0, 0, 0, 1436, 10078, 1, 0, 0, 0, 1438, 10082, 1, 0, 0, 0, 1440, 10084,
		1, 0, 0, 0, 1442, 10089, 1, 0, 0, 0, 1444, 10094, 1, 0, 0, 0, 1446, 10100,
		1, 0, 0, 0, 1448, 10104, 1, 0, 0, 0, 1450, 10106, 1, 0, 0, 0, 1452, 10111,
		1, 0, 0, 0, 1454, 10141, 1, 0, 0, 0, 1456, 10143, 1, 0, 0, 0, 1458, 10161,
		1, 0, 0, 0, 1460, 10165, 1, 0, 0, 0, 1462, 10167, 1, 0, 0, 0, 1464, 10172,
		1, 0, 0, 0, 1466, 10181, 1, 0, 0, 0, 1468, 10183, 1, 0, 0, 0, 1470, 10191,
		1, 0, 0, 0, 1472, 10195, 1, 0, 0, 0, 1474, 10197, 1, 0, 0, 0, 1476, 10201,
		1, 0, 0, 0, 1478, 10212, 1, 0, 0, 0, 1480, 10229, 1, 0, 0, 0, 1482, 10235,
		1, 0, 0, 0, 1484, 10237, 1, 0, 0, 0, 1486, 10247, 1, 0, 0, 0, 1488, 10250,
		1, 0, 0, 0, 1490, 10254, 1, 0, 0, 0, 1492, 10262, 1, 0, 0, 0, 1494, 10264,
		1, 0, 0, 0, 1496, 10267, 1, 0, 0, 0, 1498, 10272, 1, 0, 0, 0, 1500, 10277,
		1, 0, 0, 0, 1502, 10299, 1, 0, 0, 0, 1504, 10313, 1, 0, 0, 0, 1506, 10317,
		1, 0, 0, 0, 1508, 10322, 1, 0, 0, 0, 1510, 10324, 1, 0, 0, 0, 1512, 10326,
		1, 0, 0, 0, 1514, 10338, 1, 0, 0, 0, 1516, 10340, 1, 0, 0, 0, 1518, 10345,
		1, 0, 0, 0, 1520, 10347, 1, 0, 0, 0, 1522, 10365, 1, 0, 0, 0, 1524, 10393,
		1, 0, 0, 0, 1526, 10403, 1, 0, 0, 0, 1528, 10412, 1, 0, 0, 0, 1530, 10417,
		1, 0, 0, 0, 1532, 10419, 1, 0, 0, 0, 1534, 10423, 1, 0, 0, 0, 1536, 10431,
		1, 0, 0, 0, 1538, 10439, 1, 0, 0, 0, 1540, 10441, 1, 0, 0, 0, 1542, 10448,
		1, 0, 0, 0, 1544, 10451, 1, 0, 0, 0, 1546, 10467, 1, 0, 0, 0, 1548, 10469,
		1, 0, 0, 0, 1550, 10483, 1, 0, 0, 0, 1552, 10485, 1, 0, 0, 0, 1554, 10512,
		1, 0, 0, 0, 1556, 10514, 1, 0, 0, 0, 1558, 10525, 1, 0, 0, 0, 1560, 10531,
		1, 0, 0, 0, 1562, 10535, 1, 0, 0, 0, 1564, 10537, 1, 0, 0, 0, 1566, 10545,
		1, 0, 0, 0, 1568, 10550, 1, 0, 0, 0, 1570, 10569, 1, 0, 0, 0, 1572, 10571,
		1, 0, 0, 0, 1574, 10576, 1, 0, 0, 0, 1576, 10580, 1, 0, 0, 0, 1578, 10583,
		1, 0, 0, 0, 1580, 10587, 1, 0, 0, 0, 1582, 10597, 1, 0, 0, 0, 1584, 10611,
		1, 0, 0, 0, 1586, 10615, 1, 0, 0, 0, 1588, 10620, 1, 0, 0, 0, 1590, 10623,
		1, 0, 0, 0, 1592, 10627, 1, 0, 0, 0, 1594, 10632, 1, 0, 0, 0, 1596, 10643,
		1, 0, 0, 0, 1598, 10647, 1, 0, 0, 0, 1600, 10651, 1, 0, 0, 0, 1602, 10655,
		1, 0, 0, 0, 1604, 10660, 1, 0, 0, 0, 1606, 10664, 1, 0, 0, 0, 1608, 10666,
		1, 0, 0, 0, 1610, 10668, 1, 0, 0, 0, 1612, 10676, 1, 0, 0, 0, 1614, 10678,
		1, 0, 0, 0, 1616, 10680, 1, 0, 0, 0, 1618, 10682, 1, 0, 0, 0, 1620, 10684,
		1, 0, 0, 0, 1622, 10692, 1, 0, 0, 0, 1624, 1625, 3, 4, 2, 0, 1625, 1626,
		5, 0, 0, 1, 1626, 1, 1, 0, 0, 0, 1627, 1628, 3, 1396, 698, 0, 1628, 3,
		1, 0, 0, 0, 1629, 1630, 3, 6, 3, 0, 1630, 5, 1, 0, 0, 0, 1631, 1633, 3,
		8, 4, 0, 1632, 1634, 5, 7, 0, 0, 1633, 1632, 1, 0, 0, 0, 1633, 1634, 1,
		0, 0, 0, 1634, 1636, 1, 0, 0, 0, 1635, 1631, 1, 0, 0, 0, 1636, 1639, 1,
		0, 0, 0, 1637, 1635, 1, 0, 0, 0, 1637, 1638, 1, 0, 0, 0, 1638, 7, 1, 0,
		0, 0, 1639, 1637, 1, 0, 0, 0, 1640, 1766, 3, 452, 226, 0, 1641, 1766, 3,
		826, 413, 0, 1642, 1766, 3, 816, 408, 0, 1643, 1766, 3, 818, 409, 0, 1644,
		1766, 3, 578, 289, 0, 1645, 1766, 3, 832, 416, 0, 1646, 1766, 3, 478, 239,
		0, 1647, 1766, 3, 322, 161, 0, 1648, 1766, 3, 328, 164, 0, 1649, 1766,
		3, 338, 169, 0, 1650, 1766, 3, 364, 182, 0, 1651, 1766, 3, 670, 335, 0,
		1652, 1766, 3, 38, 19, 0, 1653, 1766, 3, 728, 364, 0, 1654, 1766, 3, 732,
		366, 0, 1655, 1766, 3, 744, 372, 0, 1656, 1766, 3, 734, 367, 0, 1657, 1766,
		3, 742, 371, 0, 1658, 1766, 3, 384, 192, 0, 1659, 1766, 3, 280, 140, 0,
		1660, 1766, 3, 828, 414, 0, 1661, 1766, 3, 96, 48, 0, 1662, 1766, 3, 720,
		360, 0, 1663, 1766, 3, 134, 67, 0, 1664, 1766, 3, 752, 376, 0, 1665, 1766,
		3, 32, 16, 0, 1666, 1766, 3, 28, 14, 0, 1667, 1766, 3, 760, 380, 0, 1668,
		1766, 3, 262, 131, 0, 1669, 1766, 3, 838, 419, 0, 1670, 1766, 3, 836, 418,
		0, 1671, 1766, 3, 380, 190, 0, 1672, 1766, 3, 850, 425, 0, 1673, 1766,
		3, 12, 6, 0, 1674, 1766, 3, 92, 46, 0, 1675, 1766, 3, 140, 70, 0, 1676,
		1766, 3, 844, 422, 0, 1677, 1766, 3, 534, 267, 0, 1678, 1766, 3, 86, 43,
		0, 1679, 1766, 3, 142, 71, 0, 1680, 1766, 3, 400, 200, 0, 1681, 1766, 3,
		264, 132, 0, 1682, 1766, 3, 456, 228, 0, 1683, 1766, 3, 696, 348, 0, 1684,
		1766, 3, 842, 421, 0, 1685, 1766, 3, 830, 415, 0, 1686, 1766, 3, 316, 158,
		0, 1687, 1766, 3, 330, 165, 0, 1688, 1766, 3, 356, 178, 0, 1689, 1766,
		3, 366, 183, 0, 1690, 1766, 3, 616, 308, 0, 1691, 1766, 3, 36, 18, 0, 1692,
		1766, 3, 270, 135, 0, 1693, 1766, 3, 482, 241, 0, 1694, 1766, 3, 496, 248,
		0, 1695, 1766, 3, 746, 373, 0, 1696, 1766, 3, 498, 249, 0, 1697, 1766,
		3, 382, 191, 0, 1698, 1766, 3, 296, 148, 0, 1699, 1766, 3, 42, 21, 0, 1700,
		1766, 3, 278, 139, 0, 1701, 1766, 3, 172, 86, 0, 1702, 1766, 3, 754, 377,
		0, 1703, 1766, 3, 260, 130, 0, 1704, 1766, 3, 310, 155, 0, 1705, 1766,
		3, 704, 352, 0, 1706, 1766, 3, 404, 202, 0, 1707, 1766, 3, 444, 222, 0,
		1708, 1766, 3, 14, 7, 0, 1709, 1766, 3, 26, 13, 0, 1710, 1766, 3, 374,
		187, 0, 1711, 1766, 3, 804, 402, 0, 1712, 1766, 3, 900, 450, 0, 1713, 1766,
		3, 952, 476, 0, 1714, 1766, 3, 458, 229, 0, 1715, 1766, 3, 928, 464, 0,
		1716, 1766, 3, 94, 47, 0, 1717, 1766, 3, 690, 345, 0, 1718, 1766, 3, 700,
		350, 0, 1719, 1766, 3, 504, 252, 0, 1720, 1766, 3, 506, 253, 0, 1721, 1766,
		3, 508, 254, 0, 1722, 1766, 3, 512, 256, 0, 1723, 1766, 3, 762, 381, 0,
		1724, 1766, 3, 314, 157, 0, 1725, 1766, 3, 708, 354, 0, 1726, 1766, 3,
		34, 17, 0, 1727, 1766, 3, 378, 189, 0, 1728, 1766, 3, 820, 410, 0, 1729,
		1766, 3, 896, 448, 0, 1730, 1766, 3, 878, 439, 0, 1731, 1766, 3, 544, 272,
		0, 1732, 1766, 3, 552, 276, 0, 1733, 1766, 3, 570, 285, 0, 1734, 1766,
		3, 368, 184, 0, 1735, 1766, 3, 588, 294, 0, 1736, 1766, 3, 902, 451, 0,
		1737, 1766, 3, 920, 460, 0, 1738, 1766, 3, 782, 391, 0, 1739, 1766, 3,
		276, 138, 0, 1740, 1766, 3, 802, 401, 0, 1741, 1766, 3, 932, 466, 0, 1742,
		1766, 3, 778, 389, 0, 1743, 1766, 3, 890, 445, 0, 1744, 1766, 3, 510, 255,
		0, 1745, 1766, 3, 710, 355, 0, 1746, 1766, 3, 678, 339, 0, 1747, 1766,
		3, 676, 338, 0, 1748, 1766, 3, 680, 340, 0, 1749, 1766, 3, 722, 361, 0,
		1750, 1766, 3, 554, 277, 0, 1751, 1766, 3, 572, 286, 0, 1752, 1766, 3,
		764, 382, 0, 1753, 1766, 3, 538, 269, 0, 1754, 1766, 3, 960, 480, 0, 1755,
		1766, 3, 786, 393, 0, 1756, 1766, 3, 530, 265, 0, 1757, 1766, 3, 784, 392,
		0, 1758, 1766, 3, 942, 471, 0, 1759, 1766, 3, 848, 424, 0, 1760, 1766,
		3, 74, 37, 0, 1761, 1766, 3, 50, 25, 0, 1762, 1766, 3, 84, 42, 0, 1763,
		1766, 3, 798, 399, 0, 1764, 1766, 3, 10, 5, 0, 1765, 1640, 1, 0, 0, 0,
		1765, 1641, 1, 0, 0, 0, 1765, 1642, 1, 0, 0, 0, 1765, 1643, 1, 0, 0, 0,
		1765, 1644, 1, 0, 0, 0, 1765, 1645, 1, 0, 0, 0, 1765, 1646, 1, 0, 0, 0,
		1765, 1647, 1, 0, 0, 0, 1765, 1648, 1, 0, 0, 0, 1765, 1649, 1, 0, 0, 0,
		1765, 1650, 1, 0, 0, 0, 1765, 1651, 1, 0, 0, 0, 1765, 1652, 1, 0, 0, 0,
		1765, 1653, 1, 0, 0, 0, 1765, 1654, 1, 0, 0, 0, 1765, 1655, 1, 0, 0, 0,
		1765, 1656, 1, 0, 0, 0, 1765, 1657, 1, 0, 0, 0, 1765, 1658, 1, 0, 0, 0,
		1765, 1659, 1, 0, 0, 0, 1765, 1660, 1, 0, 0, 0, 1765, 1661, 1, 0, 0, 0,
		1765, 1662, 1, 0, 0, 0, 1765, 1663, 1, 0, 0, 0, 1765, 1664, 1, 0, 0, 0,
		1765, 1665, 1, 0, 0, 0, 1765, 1666, 1, 0, 0, 0, 1765, 1667, 1, 0, 0, 0,
		1765, 1668, 1, 0, 0, 0, 1765, 1669, 1, 0, 0, 0, 1765, 1670, 1, 0, 0, 0,
		1765, 1671, 1, 0, 0, 0, 1765, 1672, 1, 0, 0, 0, 1765, 1673, 1, 0, 0, 0,
		1765, 1674, 1, 0, 0, 0, 1765, 1675, 1, 0, 0, 0, 1765, 1676, 1, 0, 0, 0,
		1765, 1677, 1, 0, 0, 0, 1765, 1678, 1, 0, 0, 0, 1765, 1679, 1, 0, 0, 0,
		1765, 1680, 1, 0, 0, 0, 1765, 1681, 1, 0, 0, 0, 1765, 1682, 1, 0, 0, 0,
		1765, 1683, 1, 0, 0, 0, 1765, 1684, 1, 0, 0, 0, 1765, 1685, 1, 0, 0, 0,
		1765, 1686, 1, 0, 0, 0, 1765, 1687, 1, 0, 0, 0, 1765, 1688, 1, 0, 0, 0,
		1765, 1689, 1, 0, 0, 0, 1765, 1690, 1, 0, 0, 0, 1765, 1691, 1, 0, 0, 0,
		1765, 1692, 1, 0, 0, 0, 1765, 1693, 1, 0, 0, 0, 1765, 1694, 1, 0, 0, 0,
		1765, 1695, 1, 0, 0, 0, 1765, 1696, 1, 0, 0, 0, 1765, 1697, 1, 0, 0, 0,
		1765, 1698, 1, 0, 0, 0, 1765, 1699, 1, 0, 0, 0, 1765, 1700, 1, 0, 0, 0,
		1765, 1701, 1, 0, 0, 0, 1765, 1702, 1, 0, 0, 0, 1765, 1703, 1, 0, 0, 0,
		1765, 1704, 1, 0, 0, 0, 1765, 1705, 1, 0, 0, 0, 1765, 1706, 1, 0, 0, 0,
		1765, 1707, 1, 0, 0, 0, 1765, 1708, 1, 0, 0, 0, 1765, 1709, 1, 0, 0, 0,
		1765, 1710, 1, 0, 0, 0, 1765, 1711, 1, 0, 0, 0, 1765, 1712, 1, 0, 0, 0,
		1765, 1713, 1, 0, 0, 0, 1765, 1714, 1, 0, 0, 0, 1765, 1715, 1, 0, 0, 0,
		1765, 1716, 1, 0, 0, 0, 1765, 1717, 1, 0, 0, 0, 1765, 1718, 1, 0, 0, 0,
		1765, 1719, 1, 0, 0, 0, 1765, 1720, 1, 0, 0, 0, 1765, 1721, 1, 0, 0, 0,
		1765, 1722, 1, 0, 0, 0, 1765, 1723, 1, 0, 0, 0, 1765, 1724, 1, 0, 0, 0,
		1765, 1725, 1, 0, 0, 0, 1765, 1726, 1, 0, 0, 0, 1765, 1727, 1, 0, 0, 0,
		1765, 1728, 1, 0, 0, 0, 1765, 1729, 1, 0, 0, 0, 1765, 1730, 1, 0, 0, 0,
		1765, 1731, 1, 0, 0, 0, 1765, 1732, 1, 0, 0, 0, 1765, 1733, 1, 0, 0, 0,
		1765, 1734, 1, 0, 0, 0, 1765, 1735, 1, 0, 0, 0, 1765, 1736, 1, 0, 0, 0,
		1765, 1737, 1, 0, 0, 0, 1765, 1738, 1, 0, 0, 0, 1765, 1739, 1, 0, 0, 0,
		1765, 1740, 1, 0, 0, 0, 1765, 1741, 1, 0, 0, 0, 1765, 1742, 1, 0, 0, 0,
		1765, 1743, 1, 0, 0, 0, 1765, 1744, 1, 0, 0, 0, 1765, 1745, 1, 0, 0, 0,
		1765, 1746, 1, 0, 0, 0, 1765, 1747, 1, 0, 0, 0, 1765, 1748, 1, 0, 0, 0,
		1765, 1749, 1, 0, 0, 0, 1765, 1750, 1, 0, 0, 0, 1765, 1751, 1, 0, 0, 0,
		1765, 1752, 1, 0, 0, 0, 1765, 1753, 1, 0, 0, 0, 1765, 1754, 1, 0, 0, 0,
		1765, 1755, 1, 0, 0, 0, 1765, 1756, 1, 0, 0, 0, 1765, 1757, 1, 0, 0, 0,
		1765, 1758, 1, 0, 0, 0, 1765, 1759, 1, 0, 0, 0, 1765, 1760, 1, 0, 0, 0,
		1765, 1761, 1, 0, 0, 0, 1765, 1762, 1, 0, 0, 0, 1765, 1763, 1, 0, 0, 0,
		1765, 1764, 1, 0, 0, 0, 1766, 9, 1, 0, 0, 0, 1767, 1769, 5, 668, 0, 0,
		1768, 1770, 5, 669, 0, 0, 1769, 1768, 1, 0, 0, 0, 1769, 1770, 1, 0, 0,
		0, 1770, 11, 1, 0, 0, 0, 1771, 1772, 5, 433, 0, 0, 1772, 1773, 3, 1210,
		605, 0, 1773, 13, 1, 0, 0, 0, 1774, 1775, 5, 46, 0, 0, 1775, 1776, 5, 311,
		0, 0, 1776, 1777, 3, 1366, 683, 0, 1777, 1778, 3, 16, 8, 0, 1778, 1779,
		3, 18, 9, 0, 1779, 15, 1, 0, 0, 0, 1780, 1783, 5, 105, 0, 0, 1781, 1783,
		1, 0, 0, 0, 1782, 1780, 1, 0, 0, 0, 1782, 1781, 1, 0, 0, 0, 1783, 17, 1,
		0, 0, 0, 1784, 1786, 3, 24, 12, 0, 1785, 1784, 1, 0, 0, 0, 1786, 1789,
		1, 0, 0, 0, 1787, 1785, 1, 0, 0, 0, 1787, 1788, 1, 0, 0, 0, 1788, 19, 1,
		0, 0, 0, 1789, 1787, 1, 0, 0, 0, 1790, 1792, 3, 22, 11, 0, 1791, 1790,
		1, 0, 0, 0, 1792, 1795, 1, 0, 0, 0, 1793, 1791, 1, 0, 0, 0, 1793, 1794,
		1, 0, 0, 0, 1794, 21, 1, 0, 0, 0, 1795, 1793, 1, 0, 0, 0, 1796, 1799, 5,
		280, 0, 0, 1797, 1800, 3, 1358, 679, 0, 1798, 1800, 5, 78, 0, 0, 1799,
		1797, 1, 0, 0, 0, 1799, 1798, 1, 0, 0, 0, 1800, 1815, 1, 0, 0, 0, 1801,
		1802, 7, 0, 0, 0, 1802, 1803, 5, 280, 0, 0, 1803, 1815, 3, 1358, 679, 0,
		1804, 1815, 5, 228, 0, 0, 1805, 1806, 5, 164, 0, 0, 1806, 1807, 5, 74,
		0, 0, 1807, 1815, 3, 1364, 682, 0, 1808, 1809, 5, 364, 0, 0, 1809, 1810,
		5, 361, 0, 0, 1810, 1815, 3, 1358, 679, 0, 1811, 1812, 5, 99, 0, 0, 1812,
		1815, 3, 1370, 685, 0, 1813, 1815, 3, 1382, 691, 0, 1814, 1796, 1, 0, 0,
		0, 1814, 1801, 1, 0, 0, 0, 1814, 1804, 1, 0, 0, 0, 1814, 1805, 1, 0, 0,
		0, 1814, 1808, 1, 0, 0, 0, 1814, 1811, 1, 0, 0, 0, 1814, 1813, 1, 0, 0,
		0, 1815, 23, 1, 0, 0, 0, 1816, 1827, 3, 22, 11, 0, 1817, 1818, 5, 341,
		0, 0, 1818, 1827, 3, 1356, 678, 0, 1819, 1820, 5, 134, 0, 0, 1820, 1827,
		3, 1370, 685, 0, 1821, 1822, 5, 311, 0, 0, 1822, 1827, 3, 1370, 685, 0,
		1823, 1824, 5, 68, 0, 0, 1824, 1825, 7, 1, 0, 0, 1825, 1827, 3, 1370, 685,
		0, 1826, 1816, 1, 0, 0, 0, 1826, 1817, 1, 0, 0, 0, 1826, 1819, 1, 0, 0,
		0, 1826, 1821, 1, 0, 0, 0, 1826, 1823, 1, 0, 0, 0, 1827, 25, 1, 0, 0, 0,
		1828, 1829, 5, 46, 0, 0, 1829, 1830, 5, 99, 0, 0, 1830, 1831, 3, 1366,
		683, 0, 1831, 1832, 3, 16, 8, 0, 1832, 1833, 3, 18, 9, 0, 1833, 27, 1,
		0, 0, 0, 1834, 1835, 5, 138, 0, 0, 1835, 1836, 7, 2, 0, 0, 1836, 1837,
		3, 1368, 684, 0, 1837, 1838, 3, 16, 8, 0, 1838, 1839, 3, 20, 10, 0, 1839,
		29, 1, 0, 0, 0, 1840, 1845, 1, 0, 0, 0, 1841, 1842, 5, 68, 0, 0, 1842,
		1843, 5, 175, 0, 0, 1843, 1845, 3, 1340, 670, 0, 1844, 1840, 1, 0, 0, 0,
		1844, 1841, 1, 0, 0, 0, 1845, 31, 1, 0, 0, 0, 1846, 1847, 5, 138, 0, 0,
		1847, 1849, 7, 2, 0, 0, 1848, 1850, 5, 30, 0, 0, 1849, 1848, 1, 0, 0, 0,
		1849, 1850, 1, 0, 0, 0, 1850, 1851, 1, 0, 0, 0, 1851, 1852, 3, 1368, 684,
		0, 1852, 1853, 3, 30, 15, 0, 1853, 1854, 3, 80, 40, 0, 1854, 33, 1, 0,
		0, 0, 1855, 1856, 5, 191, 0, 0, 1856, 1859, 7, 3, 0, 0, 1857, 1858, 5,
		220, 0, 0, 1858, 1860, 5, 389, 0, 0, 1859, 1857, 1, 0, 0, 0, 1859, 1860,
		1, 0, 0, 0, 1860, 1861, 1, 0, 0, 0, 1861, 1862, 3, 1370, 685, 0, 1862,
		35, 1, 0, 0, 0, 1863, 1864, 5, 46, 0, 0, 1864, 1865, 5, 66, 0, 0, 1865,
		1866, 3, 1366, 683, 0, 1866, 1867, 3, 16, 8, 0, 1867, 1868, 3, 18, 9, 0,
		1868, 37, 1, 0, 0, 0, 1869, 1870, 5, 138, 0, 0, 1870, 1871, 5, 66, 0, 0,
		1871, 1872, 3, 1368, 684, 0, 1872, 1873, 3, 40, 20, 0, 1873, 1874, 5, 99,
		0, 0, 1874, 1875, 3, 1370, 685, 0, 1875, 39, 1, 0, 0, 0, 1876, 1877, 7,
		4, 0, 0, 1877, 41, 1, 0, 0, 0, 1878, 1879, 5, 46, 0, 0, 1879, 1883, 5,
		316, 0, 0, 1880, 1881, 5, 220, 0, 0, 1881, 1882, 5, 77, 0, 0, 1882, 1884,
		5, 389, 0, 0, 1883, 1880, 1, 0, 0, 0, 1883, 1884, 1, 0, 0, 0, 1884, 1890,
		1, 0, 0, 0, 1885, 1886, 3, 44, 22, 0, 1886, 1887, 5, 106, 0, 0, 1887, 1888,
		3, 1368, 684, 0, 1888, 1891, 1, 0, 0, 0, 1889, 1891, 3, 1372, 686, 0, 1890,
		1885, 1, 0, 0, 0, 1890, 1889, 1, 0, 0, 0, 1891, 1892, 1, 0, 0, 0, 1892,
		1893, 3, 46, 23, 0, 1893, 43, 1, 0, 0, 0, 1894, 1897, 3, 1372, 686, 0,
		1895, 1897, 1, 0, 0, 0, 1896, 1894, 1, 0, 0, 0, 1896, 1895, 1, 0, 0, 0,
		1897, 45, 1, 0, 0, 0, 1898, 1900, 3, 48, 24, 0, 1899, 1898, 1, 0, 0, 0,
		1900, 1903, 1, 0, 0, 0, 1901, 1899, 1, 0, 0, 0, 1901, 1902, 1, 0, 0, 0,
		1902, 47, 1, 0, 0, 0, 1903, 1901, 1, 0, 0, 0, 1904, 1911, 3, 172, 86, 0,
		1905, 1911, 3, 588, 294, 0, 1906, 1911, 3, 278, 139, 0, 1907, 1911, 3,
		404, 202, 0, 1908, 1911, 3, 552, 276, 0, 1909, 1911, 3, 798, 399, 0, 1910,
		1904, 1, 0, 0, 0, 1910, 1905, 1, 0, 0, 0, 1910, 1906, 1, 0, 0, 0, 1910,
		1907, 1, 0, 0, 0, 1910, 1908, 1, 0, 0, 0, 1910, 1909, 1, 0, 0, 0, 1911,
		49, 1, 0, 0, 0, 1912, 1914, 5, 326, 0, 0, 1913, 1915, 7, 5, 0, 0, 1914,
		1913, 1, 0, 0, 0, 1914, 1915, 1, 0, 0, 0, 1915, 1916, 1, 0, 0, 0, 1916,
		1917, 3, 52, 26, 0, 1917, 51, 1, 0, 0, 0, 1918, 1919, 5, 349, 0, 0, 1919,
		1927, 3, 792, 396, 0, 1920, 1921, 5, 325, 0, 0, 1921, 1922, 5, 154, 0,
		0, 1922, 1923, 5, 36, 0, 0, 1923, 1924, 5, 349, 0, 0, 1924, 1927, 3, 792,
		396, 0, 1925, 1927, 3, 56, 28, 0, 1926, 1918, 1, 0, 0, 0, 1926, 1920, 1,
		0, 0, 0, 1926, 1925, 1, 0, 0, 0, 1927, 53, 1, 0, 0, 0, 1928, 1929, 3, 58,
		29, 0, 1929, 1930, 7, 6, 0, 0, 1930, 1931, 3, 60, 30, 0, 1931, 55, 1, 0,
		0, 0, 1932, 1958, 3, 54, 27, 0, 1933, 1934, 3, 58, 29, 0, 1934, 1935, 5,
		64, 0, 0, 1935, 1936, 5, 434, 0, 0, 1936, 1958, 1, 0, 0, 0, 1937, 1938,
		5, 411, 0, 0, 1938, 1939, 5, 379, 0, 0, 1939, 1958, 3, 68, 34, 0, 1940,
		1941, 5, 152, 0, 0, 1941, 1958, 3, 1358, 679, 0, 1942, 1943, 5, 316, 0,
		0, 1943, 1958, 3, 1358, 679, 0, 1944, 1945, 5, 260, 0, 0, 1945, 1958, 3,
		70, 35, 0, 1946, 1947, 5, 311, 0, 0, 1947, 1958, 3, 72, 36, 0, 1948, 1949,
		5, 325, 0, 0, 1949, 1950, 5, 106, 0, 0, 1950, 1958, 3, 72, 36, 0, 1951,
		1952, 5, 376, 0, 0, 1952, 1953, 5, 272, 0, 0, 1953, 1958, 3, 1228, 614,
		0, 1954, 1955, 5, 349, 0, 0, 1955, 1956, 5, 330, 0, 0, 1956, 1958, 3, 1358,
		679, 0, 1957, 1932, 1, 0, 0, 0, 1957, 1933, 1, 0, 0, 0, 1957, 1937, 1,
		0, 0, 0, 1957, 1940, 1, 0, 0, 0, 1957, 1942, 1, 0, 0, 0, 1957, 1944, 1,
		0, 0, 0, 1957, 1946, 1, 0, 0, 0, 1957, 1948, 1, 0, 0, 0, 1957, 1951, 1,
		0, 0, 0, 1957, 1954, 1, 0, 0, 0, 1958, 57, 1, 0, 0, 0, 1959, 1964, 3, 1372,
		686, 0, 1960, 1961, 5, 11, 0, 0, 1961, 1963, 3, 1372, 686, 0, 1962, 1960,
		1, 0, 0, 0, 1963, 1966, 1, 0, 0, 0, 1964, 1962, 1, 0, 0, 0, 1964, 1965,
		1, 0, 0, 0, 1965, 59, 1, 0, 0, 0, 1966, 1964, 1, 0, 0, 0, 1967, 1972, 3,
		62, 31, 0, 1968, 1969, 5, 6, 0, 0, 1969, 1971, 3, 62, 31, 0, 1970, 1968,
		1, 0, 0, 0, 1971, 1974, 1, 0, 0, 0, 1972, 1970, 1, 0, 0, 0, 1972, 1973,
		1, 0, 0, 0, 1973, 61, 1, 0, 0, 0, 1974, 1972, 1, 0, 0, 0, 1975, 1978, 3,
		66, 33, 0, 1976, 1978, 3, 292, 146, 0, 1977, 1975, 1, 0, 0, 0, 1977, 1976,
		1, 0, 0, 0, 1978, 63, 1, 0, 0, 0, 1979, 1980, 5, 293, 0, 0, 1980, 1985,
		7, 7, 0, 0, 1981, 1982, 5, 303, 0, 0, 1982, 1985, 5, 293, 0, 0, 1983, 1985,
		5, 323, 0, 0, 1984, 1979, 1, 0, 0, 0, 1984, 1981, 1, 0, 0, 0, 1984, 1983,
		1, 0, 0, 0, 1985, 65, 1, 0, 0, 0, 1986, 1991, 5, 96, 0, 0, 1987, 1991,
		5, 60, 0, 0, 1988, 1991, 5, 80, 0, 0, 1989, 1991, 3, 72, 36, 0, 1990, 1986,
		1, 0, 0, 0, 1990, 1987, 1, 0, 0, 0, 1990, 1988, 1, 0, 0, 0, 1990, 1989,
		1, 0, 0, 0, 1991, 67, 1, 0, 0, 0, 1992, 2008, 3, 1358, 679, 0, 1993, 2008,
		3, 1382, 691, 0, 1994, 1995, 3, 1152, 576, 0, 1995, 1996, 3, 1358, 679,
		0, 1996, 1997, 3, 1156, 578, 0, 1997, 2008, 1, 0, 0, 0, 1998, 1999, 3,
		1152, 576, 0, 1999, 2000, 5, 2, 0, 0, 2000, 2001, 3, 1356, 678, 0, 2001,
		2002, 5, 3, 0, 0, 2002, 2003, 3, 1358, 679, 0, 2003, 2008, 1, 0, 0, 0,
		2004, 2008, 3, 292, 146, 0, 2005, 2008, 5, 53, 0, 0, 2006, 2008, 5, 245,
		0, 0, 2007, 1992, 1, 0, 0, 0, 2007, 1993, 1, 0, 0, 0, 2007, 1994, 1, 0,
		0, 0, 2007, 1998, 1, 0, 0, 0, 2007, 2004, 1, 0, 0, 0, 2007, 2005, 1, 0,
		0, 0, 2007, 2006, 1, 0, 0, 0, 2008, 69, 1, 0, 0, 0, 2009, 2013, 3, 1358,
		679, 0, 2010, 2013, 5, 53, 0, 0, 2011, 2013, 1, 0, 0, 0, 2012, 2009, 1,
		0, 0, 0, 2012, 2010, 1, 0, 0, 0, 2012, 2011, 1, 0, 0, 0, 2013, 71, 1, 0,
		0, 0, 2014, 2017, 3, 1378, 689, 0, 2015, 2017, 3, 1358, 679, 0, 2016, 2014,
		1, 0, 0, 0, 2016, 2015, 1, 0, 0, 0, 2017, 73, 1, 0, 0, 0, 2018, 2019, 5,
		306, 0, 0, 2019, 2020, 3, 76, 38, 0, 2020, 75, 1, 0, 0, 0, 2021, 2030,
		3, 78, 39, 0, 2022, 2023, 5, 411, 0, 0, 2023, 2030, 5, 379, 0, 0, 2024,
		2025, 5, 349, 0, 0, 2025, 2026, 5, 235, 0, 0, 2026, 2030, 5, 242, 0, 0,
		2027, 2028, 5, 325, 0, 0, 2028, 2030, 5, 106, 0, 0, 2029, 2021, 1, 0, 0,
		0, 2029, 2022, 1, 0, 0, 0, 2029, 2024, 1, 0, 0, 0, 2029, 2027, 1, 0, 0,
		0, 2030, 77, 1, 0, 0, 0, 2031, 2034, 3, 58, 29, 0, 2032, 2034, 5, 30, 0,
		0, 2033, 2031, 1, 0, 0, 0, 2033, 2032, 1, 0, 0, 0, 2034, 79, 1, 0, 0, 0,
		2035, 2036, 5, 326, 0, 0, 2036, 2039, 3, 52, 26, 0, 2037, 2039, 3, 74,
		37, 0, 2038, 2035, 1, 0, 0, 0, 2038, 2037, 1, 0, 0, 0, 2039, 81, 1, 0,
		0, 0, 2040, 2041, 5, 326, 0, 0, 2041, 2044, 3, 56, 28, 0, 2042, 2044, 3,
		74, 37, 0, 2043, 2040, 1, 0, 0, 0, 2043, 2042, 1, 0, 0, 0, 2044, 83, 1,
		0, 0, 0, 2045, 2055, 5, 328, 0, 0, 2046, 2056, 3, 58, 29, 0, 2047, 2048,
		5, 411, 0, 0, 2048, 2056, 5, 379, 0, 0, 2049, 2050, 5, 349, 0, 0, 2050,
		2051, 5, 235, 0, 0, 2051, 2056, 5, 242, 0, 0, 2052, 2053, 5, 325, 0, 0,
		2053, 2056, 5, 106, 0, 0, 2054, 2056, 5, 30, 0, 0, 2055, 2046, 1, 0, 0,
		0, 2055, 2047, 1, 0, 0, 0, 2055, 2049, 1, 0, 0, 0, 2055, 2052, 1, 0, 0,
		0, 2055, 2054, 1, 0, 0, 0, 2056, 85, 1, 0, 0, 0, 2057, 2058, 5, 326, 0,
		0, 2058, 2059, 5, 165, 0, 0, 2059, 2060, 3, 88, 44, 0, 2060, 2061, 3, 90,
		45, 0, 2061, 87, 1, 0, 0, 0, 2062, 2065, 5, 30, 0, 0, 2063, 2065, 3, 1334,
		667, 0, 2064, 2062, 1, 0, 0, 0, 2064, 2063, 1, 0, 0, 0, 2065, 89, 1, 0,
		0, 0, 2066, 2067, 7, 8, 0, 0, 2067, 91, 1, 0, 0, 0, 2068, 2069, 5, 155,
		0, 0, 2069, 93, 1, 0, 0, 0, 2070, 2071, 5, 187, 0, 0, 2071, 2072, 7, 9,
		0, 0, 2072, 95, 1, 0, 0, 0, 2073, 2074, 5, 138, 0, 0, 2074, 2077, 5, 92,
		0, 0, 2075, 2076, 5, 220, 0, 0, 2076, 2078, 5, 389, 0, 0, 2077, 2075, 1,
		0, 0, 0, 2077, 2078, 1, 0, 0, 0, 2078, 2079, 1, 0, 0, 0, 2079, 2082, 3,
		1074, 537, 0, 2080, 2083, 3, 98, 49, 0, 2081, 2083, 3, 100, 50, 0, 2082,
		2080, 1, 0, 0, 0, 2082, 2081, 1, 0, 0, 0, 2083, 2183, 1, 0, 0, 0, 2084,
		2085, 5, 138, 0, 0, 2085, 2086, 5, 92, 0, 0, 2086, 2087, 5, 30, 0, 0, 2087,
		2088, 5, 68, 0, 0, 2088, 2089, 5, 344, 0, 0, 2089, 2093, 3, 1340, 670,
		0, 2090, 2091, 5, 274, 0, 0, 2091, 2092, 5, 147, 0, 0, 2092, 2094, 3, 1370,
		685, 0, 2093, 2090, 1, 0, 0, 0, 2093, 2094, 1, 0, 0, 0, 2094, 2095, 1,
		0, 0, 0, 2095, 2096, 5, 326, 0, 0, 2096, 2097, 5, 344, 0, 0, 2097, 2098,
		3, 1340, 670, 0, 2098, 2099, 3, 938, 469, 0, 2099, 2183, 1, 0, 0, 0, 2100,
		2101, 5, 138, 0, 0, 2101, 2104, 5, 226, 0, 0, 2102, 2103, 5, 220, 0, 0,
		2103, 2105, 5, 389, 0, 0, 2104, 2102, 1, 0, 0, 0, 2104, 2105, 1, 0, 0,
		0, 2105, 2106, 1, 0, 0, 0, 2106, 2109, 3, 1336, 668, 0, 2107, 2110, 3,
		98, 49, 0, 2108, 2110, 3, 102, 51, 0, 2109, 2107, 1, 0, 0, 0, 2109, 2108,
		1, 0, 0, 0, 2110, 2183, 1, 0, 0, 0, 2111, 2112, 5, 138, 0, 0, 2112, 2113,
		5, 226, 0, 0, 2113, 2114, 5, 30, 0, 0, 2114, 2115, 5, 68, 0, 0, 2115, 2116,
		5, 344, 0, 0, 2116, 2120, 3, 1340, 670, 0, 2117, 2118, 5, 274, 0, 0, 2118,
		2119, 5, 147, 0, 0, 2119, 2121, 3, 1370, 685, 0, 2120, 2117, 1, 0, 0, 0,
		2120, 2121, 1, 0, 0, 0, 2121, 2122, 1, 0, 0, 0, 2122, 2123, 5, 326, 0,
		0, 2123, 2124, 5, 344, 0, 0, 2124, 2125, 3, 1340, 670, 0, 2125, 2126, 3,
		938, 469, 0, 2126, 2183, 1, 0, 0, 0, 2127, 2128, 5, 138, 0, 0, 2128, 2131,
		5, 321, 0, 0, 2129, 2130, 5, 220, 0, 0, 2130, 2132, 5, 389, 0, 0, 2131,
		2129, 1, 0, 0, 0, 2131, 2132, 1, 0, 0, 0, 2132, 2133, 1, 0, 0, 0, 2133,
		2134, 3, 1336, 668, 0, 2134, 2135, 3, 98, 49, 0, 2135, 2183, 1, 0, 0, 0,
		2136, 2137, 5, 138, 0, 0, 2137, 2140, 5, 369, 0, 0, 2138, 2139, 5, 220,
		0, 0, 2139, 2141, 5, 389, 0, 0, 2140, 2138, 1, 0, 0, 0, 2140, 2141, 1,
		0, 0, 0, 2141, 2142, 1, 0, 0, 0, 2142, 2143, 3, 1336, 668, 0, 2143, 2144,
		3, 98, 49, 0, 2144, 2183, 1, 0, 0, 0, 2145, 2146, 5, 138, 0, 0, 2146, 2147,
		5, 251, 0, 0, 2147, 2150, 5, 369, 0, 0, 2148, 2149, 5, 220, 0, 0, 2149,
		2151, 5, 389, 0, 0, 2150, 2148, 1, 0, 0, 0, 2150, 2151, 1, 0, 0, 0, 2151,
		2152, 1, 0, 0, 0, 2152, 2153, 3, 1336, 668, 0, 2153, 2154, 3, 98, 49, 0,
		2154, 2183, 1, 0, 0, 0, 2155, 2156, 5, 138, 0, 0, 2156, 2157, 5, 251, 0,
		0, 2157, 2158, 5, 369, 0, 0, 2158, 2159, 5, 30, 0, 0, 2159, 2160, 5, 68,
		0, 0, 2160, 2161, 5, 344, 0, 0, 2161, 2165, 3, 1340, 670, 0, 2162, 2163,
		5, 274, 0, 0, 2163, 2164, 5, 147, 0, 0, 2164, 2166, 3, 1370, 685, 0, 2165,
		2162, 1, 0, 0, 0, 2165, 2166, 1, 0, 0, 0, 2166, 2167, 1, 0, 0, 0, 2167,
		2168, 5, 326, 0, 0, 2168, 2169, 5, 344, 0, 0, 2169, 2170, 3, 1340, 670,
		0, 2170, 2171, 3, 938, 469, 0, 2171, 2183, 1, 0, 0, 0, 2172, 2173, 5, 138,
		0, 0, 2173, 2174, 5, 63, 0, 0, 2174, 2177, 5, 92, 0, 0, 2175, 2176, 5,
		220, 0, 0, 2176, 2178, 5, 389, 0, 0, 2177, 2175, 1, 0, 0, 0, 2177, 2178,
		1, 0, 0, 0, 2178, 2179, 1, 0, 0, 0, 2179, 2180, 3, 1074, 537, 0, 2180,
		2181, 3, 98, 49, 0, 2181, 2183, 1, 0, 0, 0, 2182, 2073, 1, 0, 0, 0, 2182,
		2084, 1, 0, 0, 0, 2182, 2100, 1, 0, 0, 0, 2182, 2111, 1, 0, 0, 0, 2182,
		2127, 1, 0, 0, 0, 2182, 2136, 1, 0, 0, 0, 2182, 2145, 1, 0, 0, 0, 2182,
		2155, 1, 0, 0, 0, 2182, 2172, 1, 0, 0, 0, 2183, 97, 1, 0, 0, 0, 2184, 2189,
		3, 104, 52, 0, 2185, 2186, 5, 6, 0, 0, 2186, 2188, 3, 104, 52, 0, 2187,
		2185, 1, 0, 0, 0, 2188, 2191, 1, 0, 0, 0, 2189, 2187, 1, 0, 0, 0, 2189,
		2190, 1, 0, 0, 0, 2190, 99, 1, 0, 0, 0, 2191, 2189, 1, 0, 0, 0, 2192, 2193,
		5, 435, 0, 0, 2193, 2194, 5, 278, 0, 0, 2194, 2195, 3, 1336, 668, 0, 2195,
		2196, 3, 128, 64, 0, 2196, 2201, 1, 0, 0, 0, 2197, 2198, 5, 436, 0, 0,
		2198, 2199, 5, 278, 0, 0, 2199, 2201, 3, 1336, 668, 0, 2200, 2192, 1, 0,
		0, 0, 2200, 2197, 1, 0, 0, 0, 2201, 101, 1, 0, 0, 0, 2202, 2203, 5, 435,
		0, 0, 2203, 2204, 5, 278, 0, 0, 2204, 2205, 3, 1336, 668, 0, 2205, 103,
		1, 0, 0, 0, 2206, 2207, 5, 133, 0, 0, 2207, 2459, 3, 188, 94, 0, 2208,
		2209, 5, 133, 0, 0, 2209, 2210, 5, 220, 0, 0, 2210, 2211, 5, 77, 0, 0,
		2211, 2212, 5, 389, 0, 0, 2212, 2459, 3, 188, 94, 0, 2213, 2214, 5, 133,
		0, 0, 2214, 2215, 5, 44, 0, 0, 2215, 2459, 3, 188, 94, 0, 2216, 2217, 5,
		133, 0, 0, 2217, 2218, 5, 44, 0, 0, 2218, 2219, 5, 220, 0, 0, 2219, 2220,
		5, 77, 0, 0, 2220, 2221, 5, 389, 0, 0, 2221, 2459, 3, 188, 94, 0, 2222,
		2223, 5, 138, 0, 0, 2223, 2224, 3, 724, 362, 0, 2224, 2225, 3, 1372, 686,
		0, 2225, 2226, 3, 106, 53, 0, 2226, 2459, 1, 0, 0, 0, 2227, 2228, 5, 138,
		0, 0, 2228, 2229, 3, 724, 362, 0, 2229, 2230, 3, 1372, 686, 0, 2230, 2231,
		5, 191, 0, 0, 2231, 2232, 5, 77, 0, 0, 2232, 2233, 5, 78, 0, 0, 2233, 2459,
		1, 0, 0, 0, 2234, 2235, 5, 138, 0, 0, 2235, 2236, 3, 724, 362, 0, 2236,
		2237, 3, 1372, 686, 0, 2237, 2238, 5, 326, 0, 0, 2238, 2239, 5, 77, 0,
		0, 2239, 2240, 5, 78, 0, 0, 2240, 2459, 1, 0, 0, 0, 2241, 2242, 5, 138,
		0, 0, 2242, 2243, 3, 724, 362, 0, 2243, 2244, 3, 1372, 686, 0, 2244, 2245,
		5, 191, 0, 0, 2245, 2246, 5, 437, 0, 0, 2246, 2459, 1, 0, 0, 0, 2247, 2248,
		5, 138, 0, 0, 2248, 2249, 3, 724, 362, 0, 2249, 2250, 3, 1372, 686, 0,
		2250, 2251, 5, 191, 0, 0, 2251, 2252, 5, 437, 0, 0, 2252, 2253, 5, 220,
		0, 0, 2253, 2254, 5, 389, 0, 0, 2254, 2459, 1, 0, 0, 0, 2255, 2256, 5,
		138, 0, 0, 2256, 2257, 3, 724, 362, 0, 2257, 2258, 3, 1372, 686, 0, 2258,
		2259, 5, 326, 0, 0, 2259, 2260, 5, 335, 0, 0, 2260, 2261, 3, 1364, 682,
		0, 2261, 2459, 1, 0, 0, 0, 2262, 2263, 5, 138, 0, 0, 2263, 2264, 3, 724,
		362, 0, 2264, 2265, 3, 1356, 678, 0, 2265, 2266, 5, 326, 0, 0, 2266, 2267,
		5, 335, 0, 0, 2267, 2268, 3, 1364, 682, 0, 2268, 2459, 1, 0, 0, 0, 2269,
		2270, 5, 138, 0, 0, 2270, 2271, 3, 724, 362, 0, 2271, 2272, 3, 1372, 686,
		0, 2272, 2273, 5, 326, 0, 0, 2273, 2274, 3, 116, 58, 0, 2274, 2459, 1,
		0, 0, 0, 2275, 2276, 5, 138, 0, 0, 2276, 2277, 3, 724, 362, 0, 2277, 2278,
		3, 1372, 686, 0, 2278, 2279, 5, 306, 0, 0, 2279, 2280, 3, 116, 58, 0, 2280,
		2459, 1, 0, 0, 0, 2281, 2282, 5, 138, 0, 0, 2282, 2283, 3, 724, 362, 0,
		2283, 2284, 3, 1372, 686, 0, 2284, 2285, 5, 326, 0, 0, 2285, 2286, 5, 338,
		0, 0, 2286, 2287, 3, 1372, 686, 0, 2287, 2459, 1, 0, 0, 0, 2288, 2289,
		5, 138, 0, 0, 2289, 2290, 3, 724, 362, 0, 2290, 2291, 3, 1372, 686, 0,
		2291, 2292, 5, 133, 0, 0, 2292, 2293, 5, 438, 0, 0, 2293, 2294, 3, 198,
		99, 0, 2294, 2295, 5, 36, 0, 0, 2295, 2296, 5, 219, 0, 0, 2296, 2297, 3,
		284, 142, 0, 2297, 2459, 1, 0, 0, 0, 2298, 2299, 5, 138, 0, 0, 2299, 2300,
		3, 724, 362, 0, 2300, 2301, 3, 1372, 686, 0, 2301, 2302, 3, 124, 62, 0,
		2302, 2459, 1, 0, 0, 0, 2303, 2304, 5, 138, 0, 0, 2304, 2305, 3, 724, 362,
		0, 2305, 2306, 3, 1372, 686, 0, 2306, 2307, 5, 191, 0, 0, 2307, 2308, 5,
		219, 0, 0, 2308, 2459, 1, 0, 0, 0, 2309, 2310, 5, 138, 0, 0, 2310, 2311,
		3, 724, 362, 0, 2311, 2312, 3, 1372, 686, 0, 2312, 2313, 5, 191, 0, 0,
		2313, 2314, 5, 219, 0, 0, 2314, 2315, 5, 220, 0, 0, 2315, 2316, 5, 389,
		0, 0, 2316, 2459, 1, 0, 0, 0, 2317, 2318, 5, 191, 0, 0, 2318, 2319, 3,
		724, 362, 0, 2319, 2320, 5, 220, 0, 0, 2320, 2321, 5, 389, 0, 0, 2321,
		2322, 3, 1372, 686, 0, 2322, 2323, 3, 108, 54, 0, 2323, 2459, 1, 0, 0,
		0, 2324, 2325, 5, 191, 0, 0, 2325, 2326, 3, 724, 362, 0, 2326, 2327, 3,
		1372, 686, 0, 2327, 2328, 3, 108, 54, 0, 2328, 2459, 1, 0, 0, 0, 2329,
		2330, 5, 138, 0, 0, 2330, 2331, 3, 724, 362, 0, 2331, 2332, 3, 1372, 686,
		0, 2332, 2333, 3, 726, 363, 0, 2333, 2334, 5, 353, 0, 0, 2334, 2335, 3,
		1118, 559, 0, 2335, 2336, 3, 110, 55, 0, 2336, 2337, 3, 112, 56, 0, 2337,
		2459, 1, 0, 0, 0, 2338, 2339, 5, 138, 0, 0, 2339, 2340, 3, 724, 362, 0,
		2340, 2341, 3, 1372, 686, 0, 2341, 2342, 3, 344, 172, 0, 2342, 2459, 1,
		0, 0, 0, 2343, 2344, 5, 133, 0, 0, 2344, 2459, 3, 208, 104, 0, 2345, 2346,
		5, 138, 0, 0, 2346, 2347, 5, 45, 0, 0, 2347, 2348, 3, 1340, 670, 0, 2348,
		2349, 3, 440, 220, 0, 2349, 2459, 1, 0, 0, 0, 2350, 2351, 5, 365, 0, 0,
		2351, 2352, 5, 45, 0, 0, 2352, 2459, 3, 1340, 670, 0, 2353, 2354, 5, 191,
		0, 0, 2354, 2355, 5, 45, 0, 0, 2355, 2356, 5, 220, 0, 0, 2356, 2357, 5,
		389, 0, 0, 2357, 2358, 3, 1340, 670, 0, 2358, 2359, 3, 108, 54, 0, 2359,
		2459, 1, 0, 0, 0, 2360, 2361, 5, 191, 0, 0, 2361, 2362, 5, 45, 0, 0, 2362,
		2363, 3, 1340, 670, 0, 2363, 2364, 3, 108, 54, 0, 2364, 2459, 1, 0, 0,
		0, 2365, 2366, 5, 326, 0, 0, 2366, 2367, 5, 372, 0, 0, 2367, 2459, 5, 270,
		0, 0, 2368, 2369, 5, 158, 0, 0, 2369, 2370, 5, 80, 0, 0, 2370, 2459, 3,
		1340, 670, 0, 2371, 2372, 5, 326, 0, 0, 2372, 2373, 5, 372, 0, 0, 2373,
		2459, 5, 158, 0, 0, 2374, 2375, 5, 326, 0, 0, 2375, 2459, 5, 439, 0, 0,
		2376, 2377, 5, 326, 0, 0, 2377, 2459, 5, 360, 0, 0, 2378, 2379, 5, 193,
		0, 0, 2379, 2380, 5, 350, 0, 0, 2380, 2459, 3, 1340, 670, 0, 2381, 2382,
		5, 193, 0, 0, 2382, 2383, 5, 139, 0, 0, 2383, 2384, 5, 350, 0, 0, 2384,
		2459, 3, 1340, 670, 0, 2385, 2386, 5, 193, 0, 0, 2386, 2387, 5, 305, 0,
		0, 2387, 2388, 5, 350, 0, 0, 2388, 2459, 3, 1340, 670, 0, 2389, 2390, 5,
		193, 0, 0, 2390, 2391, 5, 350, 0, 0, 2391, 2459, 5, 30, 0, 0, 2392, 2393,
		5, 193, 0, 0, 2393, 2394, 5, 350, 0, 0, 2394, 2459, 5, 99, 0, 0, 2395,
		2396, 5, 186, 0, 0, 2396, 2397, 5, 350, 0, 0, 2397, 2459, 3, 1340, 670,
		0, 2398, 2399, 5, 186, 0, 0, 2399, 2400, 5, 350, 0, 0, 2400, 2459, 5, 30,
		0, 0, 2401, 2402, 5, 186, 0, 0, 2402, 2403, 5, 350, 0, 0, 2403, 2459, 5,
		99, 0, 0, 2404, 2405, 5, 193, 0, 0, 2405, 2406, 5, 314, 0, 0, 2406, 2459,
		3, 1340, 670, 0, 2407, 2408, 5, 193, 0, 0, 2408, 2409, 5, 139, 0, 0, 2409,
		2410, 5, 314, 0, 0, 2410, 2459, 3, 1340, 670, 0, 2411, 2412, 5, 193, 0,
		0, 2412, 2413, 5, 305, 0, 0, 2413, 2414, 5, 314, 0, 0, 2414, 2459, 3, 1340,
		670, 0, 2415, 2416, 5, 186, 0, 0, 2416, 2417, 5, 314, 0, 0, 2417, 2459,
		3, 1340, 670, 0, 2418, 2419, 5, 228, 0, 0, 2419, 2459, 3, 1336, 668, 0,
		2420, 2421, 5, 262, 0, 0, 2421, 2422, 5, 228, 0, 0, 2422, 2459, 3, 1336,
		668, 0, 2423, 2424, 5, 268, 0, 0, 2424, 2459, 3, 524, 262, 0, 2425, 2426,
		5, 77, 0, 0, 2426, 2459, 5, 268, 0, 0, 2427, 2428, 5, 275, 0, 0, 2428,
		2429, 5, 94, 0, 0, 2429, 2459, 3, 1368, 684, 0, 2430, 2431, 5, 326, 0,
		0, 2431, 2432, 5, 344, 0, 0, 2432, 2459, 3, 1340, 670, 0, 2433, 2434, 5,
		326, 0, 0, 2434, 2459, 3, 116, 58, 0, 2435, 2436, 5, 306, 0, 0, 2436, 2459,
		3, 116, 58, 0, 2437, 2438, 5, 305, 0, 0, 2438, 2439, 5, 219, 0, 0, 2439,
		2459, 3, 114, 57, 0, 2440, 2441, 5, 193, 0, 0, 2441, 2442, 5, 407, 0, 0,
		2442, 2443, 5, 242, 0, 0, 2443, 2459, 5, 320, 0, 0, 2444, 2445, 5, 186,
		0, 0, 2445, 2446, 5, 407, 0, 0, 2446, 2447, 5, 242, 0, 0, 2447, 2459, 5,
		320, 0, 0, 2448, 2449, 5, 209, 0, 0, 2449, 2450, 5, 407, 0, 0, 2450, 2451,
		5, 242, 0, 0, 2451, 2459, 5, 320, 0, 0, 2452, 2453, 5, 262, 0, 0, 2453,
		2454, 5, 209, 0, 0, 2454, 2455, 5, 407, 0, 0, 2455, 2456, 5, 242, 0, 0,
		2456, 2459, 5, 320, 0, 0, 2457, 2459, 3, 344, 172, 0, 2458, 2206, 1, 0,
		0, 0, 2458, 2208, 1, 0, 0, 0, 2458, 2213, 1, 0, 0, 0, 2458, 2216, 1, 0,
		0, 0, 2458, 2222, 1, 0, 0, 0, 2458, 2227, 1, 0, 0, 0, 2458, 2234, 1, 0,
		0, 0, 2458, 2241, 1, 0, 0, 0, 2458, 2247, 1, 0, 0, 0, 2458, 2255, 1, 0,
		0, 0, 2458, 2262, 1, 0, 0, 0, 2458, 2269, 1, 0, 0, 0, 2458, 2275, 1, 0,
		0, 0, 2458, 2281, 1, 0, 0, 0, 2458, 2288, 1, 0, 0, 0, 2458, 2298, 1, 0,
		0, 0, 2458, 2303, 1, 0, 0, 0, 2458, 2309, 1, 0, 0, 0, 2458, 2317, 1, 0,
		0, 0, 2458, 2324, 1, 0, 0, 0, 2458, 2329, 1, 0, 0, 0, 2458, 2338, 1, 0,
		0, 0, 2458, 2343, 1, 0, 0, 0, 2458, 2345, 1, 0, 0, 0, 2458, 2350, 1, 0,
		0, 0, 2458, 2353, 1, 0, 0, 0, 2458, 2360, 1, 0, 0, 0, 2458, 2365, 1, 0,
		0, 0, 2458, 2368, 1, 0, 0, 0, 2458, 2371, 1, 0, 0, 0, 2458, 2374, 1, 0,
		0, 0, 2458, 2376, 1, 0, 0, 0, 2458, 2378, 1, 0, 0, 0, 2458, 2381, 1, 0,
		0, 0, 2458, 2385, 1, 0, 0, 0, 2458, 2389, 1, 0, 0, 0, 2458, 2392, 1, 0,
		0, 0, 2458, 2395, 1, 0, 0, 0, 2458, 2398, 1, 0, 0, 0, 2458, 2401, 1, 0,
		0, 0, 2458, 2404, 1, 0, 0, 0, 2458, 2407, 1, 0, 0, 0, 2458, 2411, 1, 0,
		0, 0, 2458, 2415, 1, 0, 0, 0, 2458, 2418, 1, 0, 0, 0, 2458, 2420, 1, 0,
		0, 0, 2458, 2423, 1, 0, 0, 0, 2458, 2425, 1, 0, 0, 0, 2458, 2427, 1, 0,
		0, 0, 2458, 2430, 1, 0, 0, 0, 2458, 2433, 1, 0, 0, 0, 2458, 2435, 1, 0,
		0, 0, 2458, 2437, 1, 0, 0, 0, 2458, 2440, 1, 0, 0, 0, 2458, 2444, 1, 0,
		0, 0, 2458, 2448, 1, 0, 0, 0, 2458, 2452, 1, 0, 0, 0, 2458, 2457, 1, 0,
		0, 0, 2459, 105, 1, 0, 0, 0, 2460, 2461, 5, 326, 0, 0, 2461, 2462, 5, 53,
		0, 0, 2462, 2466, 3, 1162, 581, 0, 2463, 2464, 5, 191, 0, 0, 2464, 2466,
		5, 53, 0, 0, 2465, 2460, 1, 0, 0, 0, 2465, 2463, 1, 0, 0, 0, 2466, 107,
		1, 0, 0, 0, 2467, 2471, 5, 150, 0, 0, 2468, 2471, 5, 308, 0, 0, 2469, 2471,
		1, 0, 0, 0, 2470, 2467, 1, 0, 0, 0, 2470, 2468, 1, 0, 0, 0, 2470, 2469,
		1, 0, 0, 0, 2471, 109, 1, 0, 0, 0, 2472, 2473, 5, 43, 0, 0, 2473, 2476,
		3, 524, 262, 0, 2474, 2476, 1, 0, 0, 0, 2475, 2472, 1, 0, 0, 0, 2475, 2474,
		1, 0, 0, 0, 2476, 111, 1, 0, 0, 0, 2477, 2478, 5, 100, 0, 0, 2478, 2481,
		3, 1162, 581, 0, 2479, 2481, 1, 0, 0, 0, 2480, 2477, 1, 0, 0, 0, 2480,
		2479, 1, 0, 0, 0, 2481, 113, 1, 0, 0, 0, 2482, 2489, 5, 263, 0, 0, 2483,
		2489, 5, 113, 0, 0, 2484, 2489, 5, 53, 0, 0, 2485, 2486, 5, 100, 0, 0,
		2486, 2487, 5, 226, 0, 0, 2487, 2489, 3, 1340, 670, 0, 2488, 2482, 1, 0,
		0, 0, 2488, 2483, 1, 0, 0, 0, 2488, 2484, 1, 0, 0, 0, 2488, 2485, 1, 0,
		0, 0, 2489, 115, 1, 0, 0, 0, 2490, 2491, 5, 2, 0, 0, 2491, 2492, 3, 120,
		60, 0, 2492, 2493, 5, 3, 0, 0, 2493, 117, 1, 0, 0, 0, 2494, 2495, 5, 105,
		0, 0, 2495, 2498, 3, 116, 58, 0, 2496, 2498, 1, 0, 0, 0, 2497, 2494, 1,
		0, 0, 0, 2497, 2496, 1, 0, 0, 0, 2498, 119, 1, 0, 0, 0, 2499, 2504, 3,
		122, 61, 0, 2500, 2501, 5, 6, 0, 0, 2501, 2503, 3, 122, 61, 0, 2502, 2500,
		1, 0, 0, 0, 2503, 2506, 1, 0, 0, 0, 2504, 2502, 1, 0, 0, 0, 2504, 2505,
		1, 0, 0, 0, 2505, 121, 1, 0, 0, 0, 2506, 2504, 1, 0, 0, 0, 2507, 2516,
		3, 1380, 690, 0, 2508, 2509, 5, 10, 0, 0, 2509, 2517, 3, 466, 233, 0, 2510,
		2511, 5, 11, 0, 0, 2511, 2514, 3, 1380, 690, 0, 2512, 2513, 5, 10, 0, 0,
		2513, 2515, 3, 466, 233, 0, 2514, 2512, 1, 0, 0, 0, 2514, 2515, 1, 0, 0,
		0, 2515, 2517, 1, 0, 0, 0, 2516, 2508, 1, 0, 0, 0, 2516, 2510, 1, 0, 0,
		0, 2516, 2517, 1, 0, 0, 0, 2517, 123, 1, 0, 0, 0, 2518, 2520, 3, 126, 63,
		0, 2519, 2518, 1, 0, 0, 0, 2520, 2521, 1, 0, 0, 0, 2521, 2519, 1, 0, 0,
		0, 2521, 2522, 1, 0, 0, 0, 2522, 125, 1, 0, 0, 0, 2523, 2527, 5, 307, 0,
		0, 2524, 2525, 3, 16, 8, 0, 2525, 2526, 3, 292, 146, 0, 2526, 2528, 1,
		0, 0, 0, 2527, 2524, 1, 0, 0, 0, 2527, 2528, 1, 0, 0, 0, 2528, 2536, 1,
		0, 0, 0, 2529, 2533, 5, 326, 0, 0, 2530, 2534, 3, 288, 144, 0, 2531, 2532,
		5, 438, 0, 0, 2532, 2534, 3, 198, 99, 0, 2533, 2530, 1, 0, 0, 0, 2533,
		2531, 1, 0, 0, 0, 2534, 2536, 1, 0, 0, 0, 2535, 2523, 1, 0, 0, 0, 2535,
		2529, 1, 0, 0, 0, 2536, 127, 1, 0, 0, 0, 2537, 2538, 5, 62, 0, 0, 2538,
		2539, 5, 415, 0, 0, 2539, 2540, 5, 105, 0, 0, 2540, 2541, 5, 2, 0, 0, 2541,
		2542, 3, 132, 66, 0, 2542, 2543, 5, 3, 0, 0, 2543, 2564, 1, 0, 0, 0, 2544,
		2545, 5, 62, 0, 0, 2545, 2546, 5, 415, 0, 0, 2546, 2547, 5, 68, 0, 0, 2547,
		2548, 5, 2, 0, 0, 2548, 2549, 3, 1280, 640, 0, 2549, 2550, 5, 3, 0, 0,
		2550, 2564, 1, 0, 0, 0, 2551, 2552, 5, 62, 0, 0, 2552, 2553, 5, 415, 0,
		0, 2553, 2554, 5, 64, 0, 0, 2554, 2555, 5, 2, 0, 0, 2555, 2556, 3, 1280,
		640, 0, 2556, 2557, 5, 3, 0, 0, 2557, 2558, 5, 94, 0, 0, 2558, 2559, 5,
		2, 0, 0, 2559, 2560, 3, 1280, 640, 0, 2560, 2561, 5, 3, 0, 0, 2561, 2564,
		1, 0, 0, 0, 2562, 2564, 5, 53, 0, 0, 2563, 2537, 1, 0, 0, 0, 2563, 2544,
		1, 0, 0, 0, 2563, 2551, 1, 0, 0, 0, 2563, 2562, 1, 0, 0, 0, 2564, 129,
		1, 0, 0, 0, 2565, 2566, 3, 1378, 689, 0, 2566, 2567, 3, 1356, 678, 0, 2567,
		131, 1, 0, 0, 0, 2568, 2573, 3, 130, 65, 0, 2569, 2570, 5, 6, 0, 0, 2570,
		2572, 3, 130, 65, 0, 2571, 2569, 1, 0, 0, 0, 2572, 2575, 1, 0, 0, 0, 2573,
		2571, 1, 0, 0, 0, 2573, 2574, 1, 0, 0, 0, 2574, 133, 1, 0, 0, 0, 2575,
		2573, 1, 0, 0, 0, 2576, 2577, 5, 138, 0, 0, 2577, 2578, 5, 353, 0, 0, 2578,
		2579, 3, 524, 262, 0, 2579, 2580, 3, 136, 68, 0, 2580, 135, 1, 0, 0, 0,
		2581, 2586, 3, 138, 69, 0, 2582, 2583, 5, 6, 0, 0, 2583, 2585, 3, 138,
		69, 0, 2584, 2582, 1, 0, 0, 0, 2585, 2588, 1, 0, 0, 0, 2586, 2584, 1, 0,
		0, 0, 2586, 2587, 1, 0, 0, 0, 2587, 137, 1, 0, 0, 0, 2588, 2586, 1, 0,
		0, 0, 2589, 2590, 5, 133, 0, 0, 2590, 2591, 5, 143, 0, 0, 2591, 2592, 3,
		1102, 551, 0, 2592, 2593, 3, 108, 54, 0, 2593, 2613, 1, 0, 0, 0, 2594,
		2595, 5, 191, 0, 0, 2595, 2598, 5, 143, 0, 0, 2596, 2597, 5, 220, 0, 0,
		2597, 2599, 5, 389, 0, 0, 2598, 2596, 1, 0, 0, 0, 2598, 2599, 1, 0, 0,
		0, 2599, 2600, 1, 0, 0, 0, 2600, 2601, 3, 1372, 686, 0, 2601, 2602, 3,
		108, 54, 0, 2602, 2613, 1, 0, 0, 0, 2603, 2604, 5, 138, 0, 0, 2604, 2605,
		5, 143, 0, 0, 2605, 2606, 3, 1372, 686, 0, 2606, 2607, 3, 726, 363, 0,
		2607, 2608, 5, 353, 0, 0, 2608, 2609, 3, 1118, 559, 0, 2609, 2610, 3, 110,
		55, 0, 2610, 2611, 3, 108, 54, 0, 2611, 2613, 1, 0, 0, 0, 2612, 2589, 1,
		0, 0, 0, 2612, 2594, 1, 0, 0, 0, 2612, 2603, 1, 0, 0, 0, 2613, 139, 1,
		0, 0, 0, 2614, 2617, 5, 157, 0, 0, 2615, 2618, 3, 954, 477, 0, 2616, 2618,
		5, 30, 0, 0, 2617, 2615, 1, 0, 0, 0, 2617, 2616, 1, 0, 0, 0, 2618, 141,
		1, 0, 0, 0, 2619, 2620, 5, 169, 0, 0, 2620, 2621, 3, 156, 78, 0, 2621,
		2622, 3, 1336, 668, 0, 2622, 2623, 3, 214, 107, 0, 2623, 2624, 3, 144,
		72, 0, 2624, 2625, 3, 146, 73, 0, 2625, 2626, 3, 148, 74, 0, 2626, 2627,
		3, 158, 79, 0, 2627, 2628, 3, 16, 8, 0, 2628, 2629, 3, 150, 75, 0, 2629,
		2630, 3, 1094, 547, 0, 2630, 2642, 1, 0, 0, 0, 2631, 2632, 5, 169, 0, 0,
		2632, 2633, 5, 2, 0, 0, 2633, 2634, 3, 894, 447, 0, 2634, 2635, 5, 3, 0,
		0, 2635, 2636, 5, 94, 0, 0, 2636, 2637, 3, 146, 73, 0, 2637, 2638, 3, 148,
		74, 0, 2638, 2639, 3, 16, 8, 0, 2639, 2640, 3, 150, 75, 0, 2640, 2642,
		1, 0, 0, 0, 2641, 2619, 1, 0, 0, 0, 2641, 2631, 1, 0, 0, 0, 2642, 143,
		1, 0, 0, 0, 2643, 2644, 7, 10, 0, 0, 2644, 145, 1, 0, 0, 0, 2645, 2648,
		5, 290, 0, 0, 2646, 2648, 1, 0, 0, 0, 2647, 2645, 1, 0, 0, 0, 2647, 2646,
		1, 0, 0, 0, 2648, 147, 1, 0, 0, 0, 2649, 2653, 3, 1358, 679, 0, 2650, 2653,
		5, 336, 0, 0, 2651, 2653, 5, 337, 0, 0, 2652, 2649, 1, 0, 0, 0, 2652, 2650,
		1, 0, 0, 0, 2652, 2651, 1, 0, 0, 0, 2653, 149, 1, 0, 0, 0, 2654, 2660,
		3, 152, 76, 0, 2655, 2656, 5, 2, 0, 0, 2656, 2657, 3, 162, 81, 0, 2657,
		2658, 5, 3, 0, 0, 2658, 2660, 1, 0, 0, 0, 2659, 2654, 1, 0, 0, 0, 2659,
		2655, 1, 0, 0, 0, 2660, 151, 1, 0, 0, 0, 2661, 2663, 3, 154, 77, 0, 2662,
		2661, 1, 0, 0, 0, 2663, 2666, 1, 0, 0, 0, 2664, 2662, 1, 0, 0, 0, 2664,
		2665, 1, 0, 0, 0, 2665, 153, 1, 0, 0, 0, 2666, 2664, 1, 0, 0, 0, 2667,
		2703, 5, 107, 0, 0, 2668, 2703, 5, 112, 0, 0, 2669, 2670, 5, 183, 0, 0,
		2670, 2671, 3, 834, 417, 0, 2671, 2672, 3, 1358, 679, 0, 2672, 2703, 1,
		0, 0, 0, 2673, 2674, 5, 78, 0, 0, 2674, 2675, 3, 834, 417, 0, 2675, 2676,
		3, 1358, 679, 0, 2676, 2703, 1, 0, 0, 0, 2677, 2703, 5, 171, 0, 0, 2678,
		2703, 5, 216, 0, 0, 2679, 2680, 5, 291, 0, 0, 2680, 2681, 3, 834, 417,
		0, 2681, 2682, 3, 1358, 679, 0, 2682, 2703, 1, 0, 0, 0, 2683, 2684, 5,
		197, 0, 0, 2684, 2685, 3, 834, 417, 0, 2685, 2686, 3, 1358, 679, 0, 2686,
		2703, 1, 0, 0, 0, 2687, 2688, 5, 209, 0, 0, 2688, 2689, 5, 291, 0, 0, 2689,
		2703, 3, 216, 108, 0, 2690, 2691, 5, 209, 0, 0, 2691, 2692, 5, 291, 0,
		0, 2692, 2703, 5, 9, 0, 0, 2693, 2694, 5, 209, 0, 0, 2694, 2695, 5, 77,
		0, 0, 2695, 2696, 5, 78, 0, 0, 2696, 2703, 3, 216, 108, 0, 2697, 2698,
		5, 209, 0, 0, 2698, 2699, 5, 78, 0, 0, 2699, 2703, 3, 216, 108, 0, 2700,
		2701, 5, 194, 0, 0, 2701, 2703, 3, 1358, 679, 0, 2702, 2667, 1, 0, 0, 0,
		2702, 2668, 1, 0, 0, 0, 2702, 2669, 1, 0, 0, 0, 2702, 2673, 1, 0, 0, 0,
		2702, 2677, 1, 0, 0, 0, 2702, 2678, 1, 0, 0, 0, 2702, 2679, 1, 0, 0, 0,
		2702, 2683, 1, 0, 0, 0, 2702, 2687, 1, 0, 0, 0, 2702, 2690, 1, 0, 0, 0,
		2702, 2693, 1, 0, 0, 0, 2702, 2697, 1, 0, 0, 0, 2702, 2700, 1, 0, 0, 0,
		2703, 155, 1, 0, 0, 0, 2704, 2707, 5, 107, 0, 0, 2705, 2707, 1, 0, 0, 0,
		2706, 2704, 1, 0, 0, 0, 2706, 2705, 1, 0, 0, 0, 2707, 157, 1, 0, 0, 0,
		2708, 2709, 3, 160, 80, 0, 2709, 2710, 5, 184, 0, 0, 2710, 2711, 3, 1358,
		679, 0, 2711, 2714, 1, 0, 0, 0, 2712, 2714, 1, 0, 0, 0, 2713, 2708, 1,
		0, 0, 0, 2713, 2712, 1, 0, 0, 0, 2714, 159, 1, 0, 0, 0, 2715, 2718, 5,
		100, 0, 0, 2716, 2718, 1, 0, 0, 0, 2717, 2715, 1, 0, 0, 0, 2717, 2716,
		1, 0, 0, 0, 2718, 161, 1, 0, 0, 0, 2719, 2724, 3, 164, 82, 0, 2720, 2721,
		5, 6, 0, 0, 2721, 2723, 3, 164, 82, 0, 2722, 2720, 1, 0, 0, 0, 2723, 2726,
		1, 0, 0, 0, 2724, 2722, 1, 0, 0, 0, 2724, 2725, 1, 0, 0, 0, 2725, 163,
		1, 0, 0, 0, 2726, 2724, 1, 0, 0, 0, 2727, 2728, 3, 1380, 690, 0, 2728,
		2729, 3, 166, 83, 0, 2729, 165, 1, 0, 0, 0, 2730, 2739, 3, 66, 33, 0, 2731,
		2739, 3, 292, 146, 0, 2732, 2739, 5, 9, 0, 0, 2733, 2734, 5, 2, 0, 0, 2734,
		2735, 3, 168, 84, 0, 2735, 2736, 5, 3, 0, 0, 2736, 2739, 1, 0, 0, 0, 2737,
		2739, 1, 0, 0, 0, 2738, 2730, 1, 0, 0, 0, 2738, 2731, 1, 0, 0, 0, 2738,
		2732, 1, 0, 0, 0, 2738, 2733, 1, 0, 0, 0, 2738, 2737, 1, 0, 0, 0, 2739,
		167, 1, 0, 0, 0, 2740, 2745, 3, 170, 85, 0, 2741, 2742, 5, 6, 0, 0, 2742,
		2744, 3, 170, 85, 0, 2743, 2741, 1, 0, 0, 0, 2744, 2747, 1, 0, 0, 0, 2745,
		2743, 1, 0, 0, 0, 2745, 2746, 1, 0, 0, 0, 2746, 169, 1, 0, 0, 0, 2747,
		2745, 1, 0, 0, 0, 2748, 2749, 3, 66, 33, 0, 2749, 171, 1, 0, 0, 0, 2750,
		2751, 5, 46, 0, 0, 2751, 2752, 3, 174, 87, 0, 2752, 2756, 5, 92, 0, 0,
		2753, 2754, 5, 220, 0, 0, 2754, 2755, 5, 77, 0, 0, 2755, 2757, 5, 389,
		0, 0, 2756, 2753, 1, 0, 0, 0, 2756, 2757, 1, 0, 0, 0, 2757, 2758, 1, 0,
		0, 0, 2758, 2789, 3, 1336, 668, 0, 2759, 2760, 5, 2, 0, 0, 2760, 2761,
		3, 176, 88, 0, 2761, 2762, 5, 3, 0, 0, 2762, 2763, 3, 238, 119, 0, 2763,
		2764, 3, 240, 120, 0, 2764, 2765, 3, 248, 124, 0, 2765, 2766, 3, 250, 125,
		0, 2766, 2767, 3, 252, 126, 0, 2767, 2768, 3, 254, 127, 0, 2768, 2790,
		1, 0, 0, 0, 2769, 2770, 5, 268, 0, 0, 2770, 2771, 3, 524, 262, 0, 2771,
		2772, 3, 178, 89, 0, 2772, 2773, 3, 240, 120, 0, 2773, 2774, 3, 248, 124,
		0, 2774, 2775, 3, 250, 125, 0, 2775, 2776, 3, 252, 126, 0, 2776, 2777,
		3, 254, 127, 0, 2777, 2790, 1, 0, 0, 0, 2778, 2779, 5, 278, 0, 0, 2779,
		2780, 5, 268, 0, 0, 2780, 2781, 3, 1336, 668, 0, 2781, 2782, 3, 178, 89,
		0, 2782, 2783, 3, 128, 64, 0, 2783, 2784, 3, 240, 120, 0, 2784, 2785, 3,
		248, 124, 0, 2785, 2786, 3, 250, 125, 0, 2786, 2787, 3, 252, 126, 0, 2787,
		2788, 3, 254, 127, 0, 2788, 2790, 1, 0, 0, 0, 2789, 2759, 1, 0, 0, 0, 2789,
		2769, 1, 0, 0, 0, 2789, 2778, 1, 0, 0, 0, 2790, 173, 1, 0, 0, 0, 2791,
		2800, 5, 347, 0, 0, 2792, 2800, 5, 345, 0, 0, 2793, 2794, 5, 245, 0, 0,
		2794, 2800, 7, 11, 0, 0, 2795, 2796, 5, 213, 0, 0, 2796, 2800, 7, 11, 0,
		0, 2797, 2800, 5, 360, 0, 0, 2798, 2800, 1, 0, 0, 0, 2799, 2791, 1, 0,
		0, 0, 2799, 2792, 1, 0, 0, 0, 2799, 2793, 1, 0, 0, 0, 2799, 2795, 1, 0,
		0, 0, 2799, 2797, 1, 0, 0, 0, 2799, 2798, 1, 0, 0, 0, 2800, 175, 1, 0,
		0, 0, 2801, 2804, 3, 180, 90, 0, 2802, 2804, 1, 0, 0, 0, 2803, 2801, 1,
		0, 0, 0, 2803, 2802, 1, 0, 0, 0, 2804, 177, 1, 0, 0, 0, 2805, 2806, 5,
		2, 0, 0, 2806, 2807, 3, 182, 91, 0, 2807, 2808, 5, 3, 0, 0, 2808, 2811,
		1, 0, 0, 0, 2809, 2811, 1, 0, 0, 0, 2810, 2805, 1, 0, 0, 0, 2810, 2809,
		1, 0, 0, 0, 2811, 179, 1, 0, 0, 0, 2812, 2817, 3, 184, 92, 0, 2813, 2814,
		5, 6, 0, 0, 2814, 2816, 3, 184, 92, 0, 2815, 2813, 1, 0, 0, 0, 2816, 2819,
		1, 0, 0, 0, 2817, 2815, 1, 0, 0, 0, 2817, 2818, 1, 0, 0, 0, 2818, 181,
		1, 0, 0, 0, 2819, 2817, 1, 0, 0, 0, 2820, 2825, 3, 186, 93, 0, 2821, 2822,
		5, 6, 0, 0, 2822, 2824, 3, 186, 93, 0, 2823, 2821, 1, 0, 0, 0, 2824, 2827,
		1, 0, 0, 0, 2825, 2823, 1, 0, 0, 0, 2825, 2826, 1, 0, 0, 0, 2826, 183,
		1, 0, 0, 0, 2827, 2825, 1, 0, 0, 0, 2828, 2832, 3, 208, 104, 0, 2829, 2832,
		3, 202, 101, 0, 2830, 2832, 3, 188, 94, 0, 2831, 2828, 1, 0, 0, 0, 2831,
		2829, 1, 0, 0, 0, 2831, 2830, 1, 0, 0, 0, 2832, 185, 1, 0, 0, 0, 2833,
		2836, 3, 190, 95, 0, 2834, 2836, 3, 208, 104, 0, 2835, 2833, 1, 0, 0, 0,
		2835, 2834, 1, 0, 0, 0, 2836, 187, 1, 0, 0, 0, 2837, 2838, 3, 1372, 686,
		0, 2838, 2839, 3, 1118, 559, 0, 2839, 2840, 3, 340, 170, 0, 2840, 2841,
		3, 192, 96, 0, 2841, 189, 1, 0, 0, 0, 2842, 2845, 3, 1372, 686, 0, 2843,
		2844, 5, 105, 0, 0, 2844, 2846, 5, 273, 0, 0, 2845, 2843, 1, 0, 0, 0, 2845,
		2846, 1, 0, 0, 0, 2846, 2847, 1, 0, 0, 0, 2847, 2848, 3, 192, 96, 0, 2848,
		191, 1, 0, 0, 0, 2849, 2851, 3, 194, 97, 0, 2850, 2849, 1, 0, 0, 0, 2851,
		2854, 1, 0, 0, 0, 2852, 2850, 1, 0, 0, 0, 2852, 2853, 1, 0, 0, 0, 2853,
		193, 1, 0, 0, 0, 2854, 2852, 1, 0, 0, 0, 2855, 2856, 5, 45, 0, 0, 2856,
		2857, 3, 1340, 670, 0, 2857, 2858, 3, 196, 98, 0, 2858, 2864, 1, 0, 0,
		0, 2859, 2864, 3, 196, 98, 0, 2860, 2864, 3, 200, 100, 0, 2861, 2862, 5,
		43, 0, 0, 2862, 2864, 3, 524, 262, 0, 2863, 2855, 1, 0, 0, 0, 2863, 2859,
		1, 0, 0, 0, 2863, 2860, 1, 0, 0, 0, 2863, 2861, 1, 0, 0, 0, 2864, 195,
		1, 0, 0, 0, 2865, 2866, 5, 77, 0, 0, 2866, 2904, 5, 78, 0, 0, 2867, 2904,
		5, 78, 0, 0, 2868, 2869, 5, 98, 0, 0, 2869, 2870, 3, 664, 332, 0, 2870,
		2871, 3, 256, 128, 0, 2871, 2904, 1, 0, 0, 0, 2872, 2873, 5, 85, 0, 0,
		2873, 2874, 5, 236, 0, 0, 2874, 2875, 3, 664, 332, 0, 2875, 2876, 3, 256,
		128, 0, 2876, 2904, 1, 0, 0, 0, 2877, 2878, 5, 42, 0, 0, 2878, 2879, 5,
		2, 0, 0, 2879, 2880, 3, 1162, 581, 0, 2880, 2881, 5, 3, 0, 0, 2881, 2882,
		3, 212, 106, 0, 2882, 2904, 1, 0, 0, 0, 2883, 2884, 5, 53, 0, 0, 2884,
		2904, 3, 1204, 602, 0, 2885, 2886, 5, 438, 0, 0, 2886, 2887, 3, 198, 99,
		0, 2887, 2895, 5, 36, 0, 0, 2888, 2889, 5, 219, 0, 0, 2889, 2896, 3, 284,
		142, 0, 2890, 2891, 5, 2, 0, 0, 2891, 2892, 3, 1162, 581, 0, 2892, 2893,
		5, 3, 0, 0, 2893, 2894, 5, 440, 0, 0, 2894, 2896, 1, 0, 0, 0, 2895, 2888,
		1, 0, 0, 0, 2895, 2890, 1, 0, 0, 0, 2896, 2904, 1, 0, 0, 0, 2897, 2898,
		5, 86, 0, 0, 2898, 2899, 3, 1336, 668, 0, 2899, 2900, 3, 214, 107, 0, 2900,
		2901, 3, 222, 111, 0, 2901, 2902, 3, 230, 115, 0, 2902, 2904, 1, 0, 0,
		0, 2903, 2865, 1, 0, 0, 0, 2903, 2867, 1, 0, 0, 0, 2903, 2868, 1, 0, 0,
		0, 2903, 2872, 1, 0, 0, 0, 2903, 2877, 1, 0, 0, 0, 2903, 2883, 1, 0, 0,
		0, 2903, 2885, 1, 0, 0, 0, 2903, 2897, 1, 0, 0, 0, 2904, 197, 1, 0, 0,
		0, 2905, 2909, 5, 139, 0, 0, 2906, 2907, 5, 147, 0, 0, 2907, 2909, 5, 53,
		0, 0, 2908, 2905, 1, 0, 0, 0, 2908, 2906, 1, 0, 0, 0, 2909, 199, 1, 0,
		0, 0, 2910, 2916, 5, 54, 0, 0, 2911, 2912, 5, 77, 0, 0, 2912, 2916, 5,
		54, 0, 0, 2913, 2914, 5, 69, 0, 0, 2914, 2916, 7, 8, 0, 0, 2915, 2910,
		1, 0, 0, 0, 2915, 2911, 1, 0, 0, 0, 2915, 2913, 1, 0, 0, 0, 2916, 201,
		1, 0, 0, 0, 2917, 2918, 5, 120, 0, 0, 2918, 2919, 3, 1336, 668, 0, 2919,
		2920, 3, 204, 102, 0, 2920, 203, 1, 0, 0, 0, 2921, 2922, 7, 12, 0, 0, 2922,
		2924, 3, 206, 103, 0, 2923, 2921, 1, 0, 0, 0, 2924, 2927, 1, 0, 0, 0, 2925,
		2923, 1, 0, 0, 0, 2925, 2926, 1, 0, 0, 0, 2926, 205, 1, 0, 0, 0, 2927,
		2925, 1, 0, 0, 0, 2928, 2929, 7, 13, 0, 0, 2929, 207, 1, 0, 0, 0, 2930,
		2931, 5, 45, 0, 0, 2931, 2932, 3, 1340, 670, 0, 2932, 2933, 3, 210, 105,
		0, 2933, 2936, 1, 0, 0, 0, 2934, 2936, 3, 210, 105, 0, 2935, 2930, 1, 0,
		0, 0, 2935, 2934, 1, 0, 0, 0, 2936, 209, 1, 0, 0, 0, 2937, 2938, 5, 42,
		0, 0, 2938, 2939, 5, 2, 0, 0, 2939, 2940, 3, 1162, 581, 0, 2940, 2941,
		5, 3, 0, 0, 2941, 2942, 3, 440, 220, 0, 2942, 2996, 1, 0, 0, 0, 2943, 2955,
		5, 98, 0, 0, 2944, 2945, 5, 2, 0, 0, 2945, 2946, 3, 216, 108, 0, 2946,
		2947, 5, 3, 0, 0, 2947, 2948, 3, 220, 110, 0, 2948, 2949, 3, 664, 332,
		0, 2949, 2950, 3, 256, 128, 0, 2950, 2951, 3, 440, 220, 0, 2951, 2956,
		1, 0, 0, 0, 2952, 2953, 3, 258, 129, 0, 2953, 2954, 3, 440, 220, 0, 2954,
		2956, 1, 0, 0, 0, 2955, 2944, 1, 0, 0, 0, 2955, 2952, 1, 0, 0, 0, 2956,
		2996, 1, 0, 0, 0, 2957, 2958, 5, 85, 0, 0, 2958, 2970, 5, 236, 0, 0, 2959,
		2960, 5, 2, 0, 0, 2960, 2961, 3, 216, 108, 0, 2961, 2962, 5, 3, 0, 0, 2962,
		2963, 3, 220, 110, 0, 2963, 2964, 3, 664, 332, 0, 2964, 2965, 3, 256, 128,
		0, 2965, 2966, 3, 440, 220, 0, 2966, 2971, 1, 0, 0, 0, 2967, 2968, 3, 258,
		129, 0, 2968, 2969, 3, 440, 220, 0, 2969, 2971, 1, 0, 0, 0, 2970, 2959,
		1, 0, 0, 0, 2970, 2967, 1, 0, 0, 0, 2971, 2996, 1, 0, 0, 0, 2972, 2973,
		5, 199, 0, 0, 2973, 2974, 3, 596, 298, 0, 2974, 2975, 5, 2, 0, 0, 2975,
		2976, 3, 224, 112, 0, 2976, 2977, 5, 3, 0, 0, 2977, 2978, 3, 220, 110,
		0, 2978, 2979, 3, 664, 332, 0, 2979, 2980, 3, 256, 128, 0, 2980, 2981,
		3, 228, 114, 0, 2981, 2982, 3, 440, 220, 0, 2982, 2996, 1, 0, 0, 0, 2983,
		2984, 5, 63, 0, 0, 2984, 2985, 5, 236, 0, 0, 2985, 2986, 5, 2, 0, 0, 2986,
		2987, 3, 216, 108, 0, 2987, 2988, 5, 3, 0, 0, 2988, 2989, 5, 86, 0, 0,
		2989, 2990, 3, 1336, 668, 0, 2990, 2991, 3, 214, 107, 0, 2991, 2992, 3,
		222, 111, 0, 2992, 2993, 3, 230, 115, 0, 2993, 2994, 3, 440, 220, 0, 2994,
		2996, 1, 0, 0, 0, 2995, 2937, 1, 0, 0, 0, 2995, 2943, 1, 0, 0, 0, 2995,
		2957, 1, 0, 0, 0, 2995, 2972, 1, 0, 0, 0, 2995, 2983, 1, 0, 0, 0, 2996,
		211, 1, 0, 0, 0, 2997, 2998, 5, 262, 0, 0, 2998, 3001, 5, 228, 0, 0, 2999,
		3001, 1, 0, 0, 0, 3000, 2997, 1, 0, 0, 0, 3000, 2999, 1, 0, 0, 0, 3001,
		213, 1, 0, 0, 0, 3002, 3003, 5, 2, 0, 0, 3003, 3004, 3, 216, 108, 0, 3004,
		3005, 5, 3, 0, 0, 3005, 3008, 1, 0, 0, 0, 3006, 3008, 1, 0, 0, 0, 3007,
		3002, 1, 0, 0, 0, 3007, 3006, 1, 0, 0, 0, 3008, 215, 1, 0, 0, 0, 3009,
		3014, 3, 218, 109, 0, 3010, 3011, 5, 6, 0, 0, 3011, 3013, 3, 218, 109,
		0, 3012, 3010, 1, 0, 0, 0, 3013, 3016, 1, 0, 0, 0, 3014, 3012, 1, 0, 0,
		0, 3014, 3015, 1, 0, 0, 0, 3015, 217, 1, 0, 0, 0, 3016, 3014, 1, 0, 0,
		0, 3017, 3018, 3, 1372, 686, 0, 3018, 219, 1, 0, 0, 0, 3019, 3020, 5, 441,
		0, 0, 3020, 3021, 5, 2, 0, 0, 3021, 3022, 3, 216, 108, 0, 3022, 3023, 5,
		3, 0, 0, 3023, 3026, 1, 0, 0, 0, 3024, 3026, 1, 0, 0, 0, 3025, 3019, 1,
		0, 0, 0, 3025, 3024, 1, 0, 0, 0, 3026, 221, 1, 0, 0, 0, 3027, 3028, 5,
		249, 0, 0, 3028, 3031, 7, 14, 0, 0, 3029, 3031, 1, 0, 0, 0, 3030, 3027,
		1, 0, 0, 0, 3030, 3029, 1, 0, 0, 0, 3031, 223, 1, 0, 0, 0, 3032, 3037,
		3, 226, 113, 0, 3033, 3034, 5, 6, 0, 0, 3034, 3036, 3, 226, 113, 0, 3035,
		3033, 1, 0, 0, 0, 3036, 3039, 1, 0, 0, 0, 3037, 3035, 1, 0, 0, 0, 3037,
		3038, 1, 0, 0, 0, 3038, 225, 1, 0, 0, 0, 3039, 3037, 1, 0, 0, 0, 3040,
		3041, 3, 602, 301, 0, 3041, 3048, 5, 105, 0, 0, 3042, 3049, 3, 684, 342,
		0, 3043, 3044, 5, 271, 0, 0, 3044, 3045, 5, 2, 0, 0, 3045, 3046, 3, 684,
		342, 0, 3046, 3047, 5, 3, 0, 0, 3047, 3049, 1, 0, 0, 0, 3048, 3042, 1,
		0, 0, 0, 3048, 3043, 1, 0, 0, 0, 3049, 227, 1, 0, 0, 0, 3050, 3051, 5,
		103, 0, 0, 3051, 3052, 5, 2, 0, 0, 3052, 3053, 3, 1162, 581, 0, 3053, 3054,
		5, 3, 0, 0, 3054, 3057, 1, 0, 0, 0, 3055, 3057, 1, 0, 0, 0, 3056, 3050,
		1, 0, 0, 0, 3056, 3055, 1, 0, 0, 0, 3057, 229, 1, 0, 0, 0, 3058, 3068,
		3, 232, 116, 0, 3059, 3068, 3, 234, 117, 0, 3060, 3061, 3, 232, 116, 0,
		3061, 3062, 3, 234, 117, 0, 3062, 3068, 1, 0, 0, 0, 3063, 3064, 3, 234,
		117, 0, 3064, 3065, 3, 232, 116, 0, 3065, 3068, 1, 0, 0, 0, 3066, 3068,
		1, 0, 0, 0, 3067, 3058, 1, 0, 0, 0, 3067, 3059, 1, 0, 0, 0, 3067, 3060,
		1, 0, 0, 0, 3067, 3063, 1, 0, 0, 0, 3067, 3066, 1, 0, 0, 0, 3068, 231,
		1, 0, 0, 0, 3069, 3070, 5, 80, 0, 0, 3070, 3071, 5, 362, 0, 0, 3071, 3072,
		3, 236, 118, 0, 3072, 233, 1, 0, 0, 0, 3073, 3074, 5, 80, 0, 0, 3074, 3075,
		5, 182, 0, 0, 3075, 3076, 3, 236, 118, 0, 3076, 235, 1, 0, 0, 0, 3077,
		3078, 5, 262, 0, 0, 3078, 3084, 5, 132, 0, 0, 3079, 3084, 5, 308, 0, 0,
		3080, 3084, 5, 150, 0, 0, 3081, 3082, 5, 326, 0, 0, 3082, 3084, 7, 15,
		0, 0, 3083, 3077, 1, 0, 0, 0, 3083, 3079, 1, 0, 0, 0, 3083, 3080, 1, 0,
		0, 0, 3083, 3081, 1, 0, 0, 0, 3084, 237, 1, 0, 0, 0, 3085, 3086, 5, 229,
		0, 0, 3086, 3087, 5, 2, 0, 0, 3087, 3088, 3, 1334, 667, 0, 3088, 3089,
		5, 3, 0, 0, 3089, 3092, 1, 0, 0, 0, 3090, 3092, 1, 0, 0, 0, 3091, 3085,
		1, 0, 0, 0, 3091, 3090, 1, 0, 0, 0, 3092, 239, 1, 0, 0, 0, 3093, 3096,
		3, 242, 121, 0, 3094, 3096, 1, 0, 0, 0, 3095, 3093, 1, 0, 0, 0, 3095, 3094,
		1, 0, 0, 0, 3096, 241, 1, 0, 0, 0, 3097, 3098, 5, 278, 0, 0, 3098, 3099,
		5, 147, 0, 0, 3099, 3100, 3, 1372, 686, 0, 3100, 3101, 5, 2, 0, 0, 3101,
		3102, 3, 244, 122, 0, 3102, 3103, 5, 3, 0, 0, 3103, 243, 1, 0, 0, 0, 3104,
		3109, 3, 246, 123, 0, 3105, 3106, 5, 6, 0, 0, 3106, 3108, 3, 246, 123,
		0, 3107, 3105, 1, 0, 0, 0, 3108, 3111, 1, 0, 0, 0, 3109, 3107, 1, 0, 0,
		0, 3109, 3110, 1, 0, 0, 0, 3110, 245, 1, 0, 0, 0, 3111, 3109, 1, 0, 0,
		0, 3112, 3113, 3, 1372, 686, 0, 3113, 3114, 3, 608, 304, 0, 3114, 3115,
		3, 610, 305, 0, 3115, 3127, 1, 0, 0, 0, 3116, 3117, 3, 1214, 607, 0, 3117,
		3118, 3, 608, 304, 0, 3118, 3119, 3, 610, 305, 0, 3119, 3127, 1, 0, 0,
		0, 3120, 3121, 5, 2, 0, 0, 3121, 3122, 3, 1162, 581, 0, 3122, 3123, 5,
		3, 0, 0, 3123, 3124, 3, 608, 304, 0, 3124, 3125, 3, 610, 305, 0, 3125,
		3127, 1, 0, 0, 0, 3126, 3112, 1, 0, 0, 0, 3126, 3116, 1, 0, 0, 0, 3126,
		3120, 1, 0, 0, 0, 3127, 247, 1, 0, 0, 0, 3128, 3129, 5, 100, 0, 0, 3129,
		3132, 3, 1340, 670, 0, 3130, 3132, 1, 0, 0, 0, 3131, 3128, 1, 0, 0, 0,
		3131, 3130, 1, 0, 0, 0, 3132, 249, 1, 0, 0, 0, 3133, 3134, 5, 105, 0, 0,
		3134, 3139, 3, 116, 58, 0, 3135, 3136, 5, 372, 0, 0, 3136, 3139, 5, 270,
		0, 0, 3137, 3139, 1, 0, 0, 0, 3138, 3133, 1, 0, 0, 0, 3138, 3135, 1, 0,
		0, 0, 3138, 3137, 1, 0, 0, 0, 3139, 251, 1, 0, 0, 0, 3140, 3141, 5, 80,
		0, 0, 3141, 3147, 5, 161, 0, 0, 3142, 3148, 5, 191, 0, 0, 3143, 3144, 5,
		182, 0, 0, 3144, 3148, 5, 313, 0, 0, 3145, 3146, 5, 285, 0, 0, 3146, 3148,
		5, 313, 0, 0, 3147, 3142, 1, 0, 0, 0, 3147, 3143, 1, 0, 0, 0, 3147, 3145,
		1, 0, 0, 0, 3148, 3151, 1, 0, 0, 0, 3149, 3151, 1, 0, 0, 0, 3150, 3140,
		1, 0, 0, 0, 3150, 3149, 1, 0, 0, 0, 3151, 253, 1, 0, 0, 0, 3152, 3153,
		5, 344, 0, 0, 3153, 3156, 3, 1340, 670, 0, 3154, 3156, 1, 0, 0, 0, 3155,
		3152, 1, 0, 0, 0, 3155, 3154, 1, 0, 0, 0, 3156, 255, 1, 0, 0, 0, 3157,
		3158, 5, 100, 0, 0, 3158, 3159, 5, 226, 0, 0, 3159, 3160, 5, 344, 0, 0,
		3160, 3163, 3, 1340, 670, 0, 3161, 3163, 1, 0, 0, 0, 3162, 3157, 1, 0,
		0, 0, 3162, 3161, 1, 0, 0, 0, 3163, 257, 1, 0, 0, 0, 3164, 3165, 5, 100,
		0, 0, 3165, 3166, 5, 226, 0, 0, 3166, 3167, 3, 1340, 670, 0, 3167, 259,
		1, 0, 0, 0, 3168, 3169, 5, 46, 0, 0, 3169, 3173, 5, 335, 0, 0, 3170, 3171,
		5, 220, 0, 0, 3171, 3172, 5, 77, 0, 0, 3172, 3174, 5, 389, 0, 0, 3173,
		3170, 1, 0, 0, 0, 3173, 3174, 1, 0, 0, 0, 3174, 3175, 1, 0, 0, 0, 3175,
		3176, 3, 524, 262, 0, 3176, 3177, 3, 870, 435, 0, 3177, 3178, 5, 80, 0,
		0, 3178, 3179, 3, 1280, 640, 0, 3179, 3180, 5, 64, 0, 0, 3180, 3181, 3,
		1056, 528, 0, 3181, 261, 1, 0, 0, 0, 3182, 3183, 5, 138, 0, 0, 3183, 3186,
		5, 335, 0, 0, 3184, 3185, 5, 220, 0, 0, 3185, 3187, 5, 389, 0, 0, 3186,
		3184, 1, 0, 0, 0, 3186, 3187, 1, 0, 0, 0, 3187, 3188, 1, 0, 0, 0, 3188,
		3189, 3, 524, 262, 0, 3189, 3190, 5, 326, 0, 0, 3190, 3191, 5, 335, 0,
		0, 3191, 3192, 3, 1364, 682, 0, 3192, 263, 1, 0, 0, 0, 3193, 3194, 5, 46,
		0, 0, 3194, 3195, 3, 174, 87, 0, 3195, 3199, 5, 92, 0, 0, 3196, 3197, 5,
		220, 0, 0, 3197, 3198, 5, 77, 0, 0, 3198, 3200, 5, 389, 0, 0, 3199, 3196,
		1, 0, 0, 0, 3199, 3200, 1, 0, 0, 0, 3200, 3201, 1, 0, 0, 0, 3201, 3202,
		3, 266, 133, 0, 3202, 3203, 5, 36, 0, 0, 3203, 3204, 3, 960, 480, 0, 3204,
		3205, 3, 268, 134, 0, 3205, 265, 1, 0, 0, 0, 3206, 3207, 3, 1336, 668,
		0, 3207, 3208, 3, 214, 107, 0, 3208, 3209, 3, 248, 124, 0, 3209, 3210,
		3, 250, 125, 0, 3210, 3211, 3, 252, 126, 0, 3211, 3212, 3, 254, 127, 0,
		3212, 267, 1, 0, 0, 0, 3213, 3217, 5, 105, 0, 0, 3214, 3218, 5, 174, 0,
		0, 3215, 3216, 5, 262, 0, 0, 3216, 3218, 5, 174, 0, 0, 3217, 3214, 1, 0,
		0, 0, 3217, 3215, 1, 0, 0, 0, 3218, 3221, 1, 0, 0, 0, 3219, 3221, 1, 0,
		0, 0, 3220, 3213, 1, 0, 0, 0, 3220, 3219, 1, 0, 0, 0, 3221, 269, 1, 0,
		0, 0, 3222, 3223, 5, 46, 0, 0, 3223, 3224, 3, 274, 137, 0, 3224, 3225,
		5, 251, 0, 0, 3225, 3229, 5, 369, 0, 0, 3226, 3227, 5, 220, 0, 0, 3227,
		3228, 5, 77, 0, 0, 3228, 3230, 5, 389, 0, 0, 3229, 3226, 1, 0, 0, 0, 3229,
		3230, 1, 0, 0, 0, 3230, 3231, 1, 0, 0, 0, 3231, 3232, 3, 272, 136, 0, 3232,
		3233, 5, 36, 0, 0, 3233, 3234, 3, 960, 480, 0, 3234, 3235, 3, 268, 134,
		0, 3235, 271, 1, 0, 0, 0, 3236, 3237, 3, 1336, 668, 0, 3237, 3238, 3, 214,
		107, 0, 3238, 3239, 3, 248, 124, 0, 3239, 3240, 3, 118, 59, 0, 3240, 3241,
		3, 254, 127, 0, 3241, 273, 1, 0, 0, 0, 3242, 3245, 5, 360, 0, 0, 3243,
		3245, 1, 0, 0, 0, 3244, 3242, 1, 0, 0, 0, 3244, 3243, 1, 0, 0, 0, 3245,
		275, 1, 0, 0, 0, 3246, 3247, 5, 298, 0, 0, 3247, 3248, 5, 251, 0, 0, 3248,
		3249, 5, 369, 0, 0, 3249, 3250, 3, 592, 296, 0, 3250, 3251, 3, 1336, 668,
		0, 3251, 3252, 3, 268, 134, 0, 3252, 277, 1, 0, 0, 0, 3253, 3254, 5, 46,
		0, 0, 3254, 3255, 3, 174, 87, 0, 3255, 3259, 5, 321, 0, 0, 3256, 3257,
		5, 220, 0, 0, 3257, 3258, 5, 77, 0, 0, 3258, 3260, 5, 389, 0, 0, 3259,
		3256, 1, 0, 0, 0, 3259, 3260, 1, 0, 0, 0, 3260, 3261, 1, 0, 0, 0, 3261,
		3262, 3, 1336, 668, 0, 3262, 3263, 3, 282, 141, 0, 3263, 279, 1, 0, 0,
		0, 3264, 3265, 5, 138, 0, 0, 3265, 3268, 5, 321, 0, 0, 3266, 3267, 5, 220,
		0, 0, 3267, 3269, 5, 389, 0, 0, 3268, 3266, 1, 0, 0, 0, 3268, 3269, 1,
		0, 0, 0, 3269, 3270, 1, 0, 0, 0, 3270, 3271, 3, 1336, 668, 0, 3271, 3272,
		3, 286, 143, 0, 3272, 281, 1, 0, 0, 0, 3273, 3276, 3, 286, 143, 0, 3274,
		3276, 1, 0, 0, 0, 3275, 3273, 1, 0, 0, 0, 3275, 3274, 1, 0, 0, 0, 3276,
		283, 1, 0, 0, 0, 3277, 3278, 5, 2, 0, 0, 3278, 3279, 3, 286, 143, 0, 3279,
		3280, 5, 3, 0, 0, 3280, 3283, 1, 0, 0, 0, 3281, 3283, 1, 0, 0, 0, 3282,
		3277, 1, 0, 0, 0, 3282, 3281, 1, 0, 0, 0, 3283, 285, 1, 0, 0, 0, 3284,
		3286, 3, 288, 144, 0, 3285, 3284, 1, 0, 0, 0, 3286, 3287, 1, 0, 0, 0, 3287,
		3285, 1, 0, 0, 0, 3287, 3288, 1, 0, 0, 0, 3288, 287, 1, 0, 0, 0, 3289,
		3290, 5, 36, 0, 0, 3290, 3320, 3, 1122, 561, 0, 3291, 3292, 5, 148, 0,
		0, 3292, 3320, 3, 292, 146, 0, 3293, 3320, 5, 173, 0, 0, 3294, 3295, 5,
		225, 0, 0, 3295, 3296, 3, 290, 145, 0, 3296, 3297, 3, 292, 146, 0, 3297,
		3320, 1, 0, 0, 0, 3298, 3299, 5, 252, 0, 0, 3299, 3320, 3, 292, 146, 0,
		3300, 3301, 5, 255, 0, 0, 3301, 3320, 3, 292, 146, 0, 3302, 3303, 5, 262,
		0, 0, 3303, 3320, 7, 16, 0, 0, 3304, 3305, 5, 274, 0, 0, 3305, 3306, 5,
		147, 0, 0, 3306, 3320, 3, 524, 262, 0, 3307, 3308, 5, 321, 0, 0, 3308,
		3309, 5, 259, 0, 0, 3309, 3320, 3, 524, 262, 0, 3310, 3311, 5, 333, 0,
		0, 3311, 3312, 3, 16, 8, 0, 3312, 3313, 3, 292, 146, 0, 3313, 3320, 1,
		0, 0, 0, 3314, 3315, 5, 307, 0, 0, 3315, 3317, 3, 16, 8, 0, 3316, 3318,
		3, 292, 146, 0, 3317, 3316, 1, 0, 0, 0, 3317, 3318, 1, 0, 0, 0, 3318, 3320,
		1, 0, 0, 0, 3319, 3289, 1, 0, 0, 0, 3319, 3291, 1, 0, 0, 0, 3319, 3293,
		1, 0, 0, 0, 3319, 3294, 1, 0, 0, 0, 3319, 3298, 1, 0, 0, 0, 3319, 3300,
		1, 0, 0, 0, 3319, 3302, 1, 0, 0, 0, 3319, 3304, 1, 0, 0, 0, 3319, 3307,
		1, 0, 0, 0, 3319, 3310, 1, 0, 0, 0, 3319, 3314, 1, 0, 0, 0, 3320, 289,
		1, 0, 0, 0, 3321, 3324, 5, 147, 0, 0, 3322, 3324, 1, 0, 0, 0, 3323, 3321,
		1, 0, 0, 0, 3323, 3322, 1, 0, 0, 0, 3324, 291, 1, 0, 0, 0, 3325, 3332,
		3, 1354, 677, 0, 3326, 3327, 5, 12, 0, 0, 3327, 3332, 3, 1354, 677, 0,
		3328, 3329, 5, 13, 0, 0, 3329, 3332, 3, 1354, 677, 0, 3330, 3332, 3, 1364,
		682, 0, 3331, 3325, 1, 0, 0, 0, 3331, 3326, 1, 0, 0, 0, 3331, 3328, 1,
		0, 0, 0, 3331, 3330, 1, 0, 0, 0, 3332, 293, 1, 0, 0, 0, 3333, 3338, 3,
		292, 146, 0, 3334, 3335, 5, 6, 0, 0, 3335, 3337, 3, 292, 146, 0, 3336,
		3334, 1, 0, 0, 0, 3337, 3340, 1, 0, 0, 0, 3338, 3336, 1, 0, 0, 0, 3338,
		3339, 1, 0, 0, 0, 3339, 295, 1, 0, 0, 0, 3340, 3338, 1, 0, 0, 0, 3341,
		3342, 5, 46, 0, 0, 3342, 3343, 3, 618, 309, 0, 3343, 3344, 3, 298, 149,
		0, 3344, 3345, 3, 308, 154, 0, 3345, 3346, 5, 238, 0, 0, 3346, 3352, 3,
		1340, 670, 0, 3347, 3348, 5, 215, 0, 0, 3348, 3349, 3, 300, 150, 0, 3349,
		3350, 3, 302, 151, 0, 3350, 3351, 3, 306, 153, 0, 3351, 3353, 1, 0, 0,
		0, 3352, 3347, 1, 0, 0, 0, 3352, 3353, 1, 0, 0, 0, 3353, 297, 1, 0, 0,
		0, 3354, 3357, 5, 352, 0, 0, 3355, 3357, 1, 0, 0, 0, 3356, 3354, 1, 0,
		0, 0, 3356, 3355, 1, 0, 0, 0, 3357, 299, 1, 0, 0, 0, 3358, 3360, 3, 1340,
		670, 0, 3359, 3361, 3, 526, 263, 0, 3360, 3359, 1, 0, 0, 0, 3360, 3361,
		1, 0, 0, 0, 3361, 301, 1, 0, 0, 0, 3362, 3363, 5, 230, 0, 0, 3363, 3366,
		3, 300, 150, 0, 3364, 3366, 1, 0, 0, 0, 3365, 3362, 1, 0, 0, 0, 3365, 3364,
		1, 0, 0, 0, 3366, 303, 1, 0, 0, 0, 3367, 3368, 5, 366, 0, 0, 3368, 3372,
		3, 300, 150, 0, 3369, 3370, 5, 262, 0, 0, 3370, 3372, 5, 366, 0, 0, 3371,
		3367, 1, 0, 0, 0, 3371, 3369, 1, 0, 0, 0, 3372, 305, 1, 0, 0, 0, 3373,
		3376, 3, 304, 152, 0, 3374, 3376, 1, 0, 0, 0, 3375, 3373, 1, 0, 0, 0, 3375,
		3374, 1, 0, 0, 0, 3376, 307, 1, 0, 0, 0, 3377, 3380, 5, 288, 0, 0, 3378,
		3380, 1, 0, 0, 0, 3379, 3377, 1, 0, 0, 0, 3379, 3378, 1, 0, 0, 0, 3380,
		309, 1, 0, 0, 0, 3381, 3382, 5, 46, 0, 0, 3382, 3383, 5, 344, 0, 0, 3383,
		3384, 3, 1340, 670, 0, 3384, 3385, 3, 312, 156, 0, 3385, 3386, 5, 246,
		0, 0, 3386, 3387, 3, 1358, 679, 0, 3387, 3388, 3, 118, 59, 0, 3388, 311,
		1, 0, 0, 0, 3389, 3390, 5, 275, 0, 0, 3390, 3393, 3, 1368, 684, 0, 3391,
		3393, 1, 0, 0, 0, 3392, 3389, 1, 0, 0, 0, 3392, 3391, 1, 0, 0, 0, 3393,
		313, 1, 0, 0, 0, 3394, 3395, 5, 191, 0, 0, 3395, 3398, 5, 344, 0, 0, 3396,
		3397, 5, 220, 0, 0, 3397, 3399, 5, 389, 0, 0, 3398, 3396, 1, 0, 0, 0, 3398,
		3399, 1, 0, 0, 0, 3399, 3400, 1, 0, 0, 0, 3400, 3401, 3, 1340, 670, 0,
		3401, 315, 1, 0, 0, 0, 3402, 3403, 5, 46, 0, 0, 3403, 3407, 5, 204, 0,
		0, 3404, 3405, 5, 220, 0, 0, 3405, 3406, 5, 77, 0, 0, 3406, 3408, 5, 389,
		0, 0, 3407, 3404, 1, 0, 0, 0, 3407, 3408, 1, 0, 0, 0, 3408, 3409, 1, 0,
		0, 0, 3409, 3410, 3, 1340, 670, 0, 3410, 3411, 3, 16, 8, 0, 3411, 3412,
		3, 318, 159, 0, 3412, 317, 1, 0, 0, 0, 3413, 3415, 3, 320, 160, 0, 3414,
		3413, 1, 0, 0, 0, 3415, 3418, 1, 0, 0, 0, 3416, 3414, 1, 0, 0, 0, 3416,
		3417, 1, 0, 0, 0, 3417, 319, 1, 0, 0, 0, 3418, 3416, 1, 0, 0, 0, 3419,
		3420, 5, 316, 0, 0, 3420, 3427, 3, 1340, 670, 0, 3421, 3422, 5, 368, 0,
		0, 3422, 3427, 3, 72, 36, 0, 3423, 3424, 5, 64, 0, 0, 3424, 3427, 3, 72,
		36, 0, 3425, 3427, 5, 150, 0, 0, 3426, 3419, 1, 0, 0, 0, 3426, 3421, 1,
		0, 0, 0, 3426, 3423, 1, 0, 0, 0, 3426, 3425, 1, 0, 0, 0, 3427, 321, 1,
		0, 0, 0, 3428, 3429, 5, 138, 0, 0, 3429, 3430, 5, 204, 0, 0, 3430, 3431,
		3, 1340, 670, 0, 3431, 3432, 5, 362, 0, 0, 3432, 3433, 3, 324, 162, 0,
		3433, 323, 1, 0, 0, 0, 3434, 3436, 3, 326, 163, 0, 3435, 3434, 1, 0, 0,
		0, 3436, 3439, 1, 0, 0, 0, 3437, 3435, 1, 0, 0, 0, 3437, 3438, 1, 0, 0,
		0, 3438, 325, 1, 0, 0, 0, 3439, 3437, 1, 0, 0, 0, 3440, 3441, 5, 94, 0,
		0, 3441, 3442, 3, 72, 36, 0, 3442, 327, 1, 0, 0, 0, 3443, 3444, 5, 138,
		0, 0, 3444, 3445, 5, 204, 0, 0, 3445, 3446, 3, 1340, 670, 0, 3446, 3447,
		3, 40, 20, 0, 3447, 3448, 3, 516, 258, 0, 3448, 3449, 3, 1340, 670, 0,
		3449, 3548, 1, 0, 0, 0, 3450, 3451, 5, 138, 0, 0, 3451, 3452, 5, 204, 0,
		0, 3452, 3453, 3, 1340, 670, 0, 3453, 3454, 3, 40, 20, 0, 3454, 3455, 3,
		514, 257, 0, 3455, 3456, 3, 524, 262, 0, 3456, 3548, 1, 0, 0, 0, 3457,
		3458, 5, 138, 0, 0, 3458, 3459, 5, 204, 0, 0, 3459, 3460, 3, 1340, 670,
		0, 3460, 3461, 3, 40, 20, 0, 3461, 3462, 5, 136, 0, 0, 3462, 3463, 3, 650,
		325, 0, 3463, 3548, 1, 0, 0, 0, 3464, 3465, 5, 138, 0, 0, 3465, 3466, 5,
		204, 0, 0, 3466, 3467, 3, 1340, 670, 0, 3467, 3468, 3, 40, 20, 0, 3468,
		3469, 5, 41, 0, 0, 3469, 3470, 5, 2, 0, 0, 3470, 3471, 3, 1118, 559, 0,
		3471, 3472, 5, 36, 0, 0, 3472, 3473, 3, 1118, 559, 0, 3473, 3474, 5, 3,
		0, 0, 3474, 3548, 1, 0, 0, 0, 3475, 3476, 5, 138, 0, 0, 3476, 3477, 5,
		204, 0, 0, 3477, 3478, 3, 1340, 670, 0, 3478, 3479, 3, 40, 20, 0, 3479,
		3480, 5, 189, 0, 0, 3480, 3481, 3, 1118, 559, 0, 3481, 3548, 1, 0, 0, 0,
		3482, 3483, 5, 138, 0, 0, 3483, 3484, 5, 204, 0, 0, 3484, 3485, 3, 1340,
		670, 0, 3485, 3486, 3, 40, 20, 0, 3486, 3487, 5, 211, 0, 0, 3487, 3488,
		3, 626, 313, 0, 3488, 3548, 1, 0, 0, 0, 3489, 3490, 5, 138, 0, 0, 3490,
		3491, 5, 204, 0, 0, 3491, 3492, 3, 1340, 670, 0, 3492, 3493, 3, 40, 20,
		0, 3493, 3494, 5, 271, 0, 0, 3494, 3495, 3, 688, 344, 0, 3495, 3548, 1,
		0, 0, 0, 3496, 3497, 5, 138, 0, 0, 3497, 3498, 5, 204, 0, 0, 3498, 3499,
		3, 1340, 670, 0, 3499, 3500, 3, 40, 20, 0, 3500, 3501, 5, 271, 0, 0, 3501,
		3502, 5, 156, 0, 0, 3502, 3503, 3, 524, 262, 0, 3503, 3504, 5, 100, 0,
		0, 3504, 3505, 3, 1340, 670, 0, 3505, 3548, 1, 0, 0, 0, 3506, 3507, 5,
		138, 0, 0, 3507, 3508, 5, 204, 0, 0, 3508, 3509, 3, 1340, 670, 0, 3509,
		3510, 3, 40, 20, 0, 3510, 3511, 5, 271, 0, 0, 3511, 3512, 5, 206, 0, 0,
		3512, 3513, 3, 524, 262, 0, 3513, 3514, 5, 100, 0, 0, 3514, 3515, 3, 1340,
		670, 0, 3515, 3548, 1, 0, 0, 0, 3516, 3517, 5, 138, 0, 0, 3517, 3518, 5,
		204, 0, 0, 3518, 3519, 3, 1340, 670, 0, 3519, 3520, 3, 40, 20, 0, 3520,
		3521, 5, 289, 0, 0, 3521, 3522, 3, 626, 313, 0, 3522, 3548, 1, 0, 0, 0,
		3523, 3524, 5, 138, 0, 0, 3524, 3525, 5, 204, 0, 0, 3525, 3526, 3, 1340,
		670, 0, 3526, 3527, 3, 40, 20, 0, 3527, 3528, 5, 442, 0, 0, 3528, 3529,
		3, 626, 313, 0, 3529, 3548, 1, 0, 0, 0, 3530, 3531, 5, 138, 0, 0, 3531,
		3532, 5, 204, 0, 0, 3532, 3533, 3, 1340, 670, 0, 3533, 3534, 3, 40, 20,
		0, 3534, 3535, 5, 443, 0, 0, 3535, 3536, 5, 62, 0, 0, 3536, 3537, 3, 1118,
		559, 0, 3537, 3538, 5, 238, 0, 0, 3538, 3539, 3, 1340, 670, 0, 3539, 3548,
		1, 0, 0, 0, 3540, 3541, 5, 138, 0, 0, 3541, 3542, 5, 204, 0, 0, 3542, 3543,
		3, 1340, 670, 0, 3543, 3544, 3, 40, 20, 0, 3544, 3545, 5, 353, 0, 0, 3545,
		3546, 3, 1118, 559, 0, 3546, 3548, 1, 0, 0, 0, 3547, 3443, 1, 0, 0, 0,
		3547, 3450, 1, 0, 0, 0, 3547, 3457, 1, 0, 0, 0, 3547, 3464, 1, 0, 0, 0,
		3547, 3475, 1, 0, 0, 0, 3547, 3482, 1, 0, 0, 0, 3547, 3489, 1, 0, 0, 0,
		3547, 3496, 1, 0, 0, 0, 3547, 3506, 1, 0, 0, 0, 3547, 3516, 1, 0, 0, 0,
		3547, 3523, 1, 0, 0, 0, 3547, 3530, 1, 0, 0, 0, 3547, 3540, 1, 0, 0, 0,
		3548, 329, 1, 0, 0, 0, 3549, 3550, 5, 46, 0, 0, 3550, 3551, 5, 63, 0, 0,
		3551, 3552, 5, 174, 0, 0, 3552, 3553, 5, 374, 0, 0, 3553, 3554, 3, 1340,
		670, 0, 3554, 3555, 3, 336, 168, 0, 3555, 3556, 3, 340, 170, 0, 3556, 331,
		1, 0, 0, 0, 3557, 3558, 5, 215, 0, 0, 3558, 3566, 3, 300, 150, 0, 3559,
		3560, 5, 262, 0, 0, 3560, 3566, 5, 215, 0, 0, 3561, 3562, 5, 366, 0, 0,
		3562, 3566, 3, 300, 150, 0, 3563, 3564, 5, 262, 0, 0, 3564, 3566, 5, 366,
		0, 0, 3565, 3557, 1, 0, 0, 0, 3565, 3559, 1, 0, 0, 0, 3565, 3561, 1, 0,
		0, 0, 3565, 3563, 1, 0, 0, 0, 3566, 333, 1, 0, 0, 0, 3567, 3569, 3, 332,
		166, 0, 3568, 3567, 1, 0, 0, 0, 3569, 3570, 1, 0, 0, 0, 3570, 3568, 1,
		0, 0, 0, 3570, 3571, 1, 0, 0, 0, 3571, 335, 1, 0, 0, 0, 3572, 3575, 3,
		334, 167, 0, 3573, 3575, 1, 0, 0, 0, 3574, 3572, 1, 0, 0, 0, 3574, 3573,
		1, 0, 0, 0, 3575, 337, 1, 0, 0, 0, 3576, 3577, 5, 138, 0, 0, 3577, 3578,
		5, 63, 0, 0, 3578, 3579, 5, 174, 0, 0, 3579, 3580, 5, 374, 0, 0, 3580,
		3581, 3, 1340, 670, 0, 3581, 3582, 3, 336, 168, 0, 3582, 3583, 3, 344,
		172, 0, 3583, 3592, 1, 0, 0, 0, 3584, 3585, 5, 138, 0, 0, 3585, 3586, 5,
		63, 0, 0, 3586, 3587, 5, 174, 0, 0, 3587, 3588, 5, 374, 0, 0, 3588, 3589,
		3, 1340, 670, 0, 3589, 3590, 3, 334, 167, 0, 3590, 3592, 1, 0, 0, 0, 3591,
		3576, 1, 0, 0, 0, 3591, 3584, 1, 0, 0, 0, 3592, 339, 1, 0, 0, 0, 3593,
		3594, 5, 273, 0, 0, 3594, 3595, 5, 2, 0, 0, 3595, 3596, 3, 342, 171, 0,
		3596, 3597, 5, 3, 0, 0, 3597, 3600, 1, 0, 0, 0, 3598, 3600, 1, 0, 0, 0,
		3599, 3593, 1, 0, 0, 0, 3599, 3598, 1, 0, 0, 0, 3600, 341, 1, 0, 0, 0,
		3601, 3606, 3, 350, 175, 0, 3602, 3603, 5, 6, 0, 0, 3603, 3605, 3, 350,
		175, 0, 3604, 3602, 1, 0, 0, 0, 3605, 3608, 1, 0, 0, 0, 3606, 3604, 1,
		0, 0, 0, 3606, 3607, 1, 0, 0, 0, 3607, 343, 1, 0, 0, 0, 3608, 3606, 1,
		0, 0, 0, 3609, 3610, 5, 273, 0, 0, 3610, 3611, 5, 2, 0, 0, 3611, 3612,
		3, 346, 173, 0, 3612, 3613, 5, 3, 0, 0, 3613, 345, 1, 0, 0, 0, 3614, 3619,
		3, 348, 174, 0, 3615, 3616, 5, 6, 0, 0, 3616, 3618, 3, 348, 174, 0, 3617,
		3615, 1, 0, 0, 0, 3618, 3621, 1, 0, 0, 0, 3619, 3617, 1, 0, 0, 0, 3619,
		3620, 1, 0, 0, 0, 3620, 347, 1, 0, 0, 0, 3621, 3619, 1, 0, 0, 0, 3622,
		3630, 3, 350, 175, 0, 3623, 3624, 5, 326, 0, 0, 3624, 3630, 3, 350, 175,
		0, 3625, 3626, 5, 133, 0, 0, 3626, 3630, 3, 350, 175, 0, 3627, 3628, 5,
		191, 0, 0, 3628, 3630, 3, 352, 176, 0, 3629, 3622, 1, 0, 0, 0, 3629, 3623,
		1, 0, 0, 0, 3629, 3625, 1, 0, 0, 0, 3629, 3627, 1, 0, 0, 0, 3630, 349,
		1, 0, 0, 0, 3631, 3632, 3, 352, 176, 0, 3632, 3633, 3, 354, 177, 0, 3633,
		351, 1, 0, 0, 0, 3634, 3635, 3, 1380, 690, 0, 3635, 353, 1, 0, 0, 0, 3636,
		3637, 3, 1358, 679, 0, 3637, 355, 1, 0, 0, 0, 3638, 3639, 5, 46, 0, 0,
		3639, 3640, 5, 324, 0, 0, 3640, 3641, 3, 1340, 670, 0, 3641, 3642, 3, 358,
		179, 0, 3642, 3643, 3, 362, 181, 0, 3643, 3644, 5, 63, 0, 0, 3644, 3645,
		5, 174, 0, 0, 3645, 3646, 5, 374, 0, 0, 3646, 3647, 3, 1340, 670, 0, 3647,
		3648, 3, 340, 170, 0, 3648, 3664, 1, 0, 0, 0, 3649, 3650, 5, 46, 0, 0,
		3650, 3651, 5, 324, 0, 0, 3651, 3652, 5, 220, 0, 0, 3652, 3653, 5, 77,
		0, 0, 3653, 3654, 5, 389, 0, 0, 3654, 3655, 3, 1340, 670, 0, 3655, 3656,
		3, 358, 179, 0, 3656, 3657, 3, 362, 181, 0, 3657, 3658, 5, 63, 0, 0, 3658,
		3659, 5, 174, 0, 0, 3659, 3660, 5, 374, 0, 0, 3660, 3661, 3, 1340, 670,
		0, 3661, 3662, 3, 340, 170, 0, 3662, 3664, 1, 0, 0, 0, 3663, 3638, 1, 0,
		0, 0, 3663, 3649, 1, 0, 0, 0, 3664, 357, 1, 0, 0, 0, 3665, 3666, 5, 353,
		0, 0, 3666, 3669, 3, 1358, 679, 0, 3667, 3669, 1, 0, 0, 0, 3668, 3665,
		1, 0, 0, 0, 3668, 3667, 1, 0, 0, 0, 3669, 359, 1, 0, 0, 0, 3670, 3673,
		5, 368, 0, 0, 3671, 3674, 3, 1358, 679, 0, 3672, 3674, 5, 78, 0, 0, 3673,
		3671, 1, 0, 0, 0, 3673, 3672, 1, 0, 0, 0, 3674, 361, 1, 0, 0, 0, 3675,
		3678, 3, 360, 180, 0, 3676, 3678, 1, 0, 0, 0, 3677, 3675, 1, 0, 0, 0, 3677,
		3676, 1, 0, 0, 0, 3678, 363, 1, 0, 0, 0, 3679, 3680, 5, 138, 0, 0, 3680,
		3681, 5, 324, 0, 0, 3681, 3687, 3, 1340, 670, 0, 3682, 3688, 3, 344, 172,
		0, 3683, 3685, 3, 360, 180, 0, 3684, 3686, 3, 344, 172, 0, 3685, 3684,
		1, 0, 0, 0, 3685, 3686, 1, 0, 0, 0, 3686, 3688, 1, 0, 0, 0, 3687, 3682,
		1, 0, 0, 0, 3687, 3683, 1, 0, 0, 0, 3688, 365, 1, 0, 0, 0, 3689, 3690,
		5, 46, 0, 0, 3690, 3691, 5, 63, 0, 0, 3691, 3692, 5, 92, 0, 0, 3692, 3693,
		3, 1336, 668, 0, 3693, 3694, 5, 2, 0, 0, 3694, 3695, 3, 176, 88, 0, 3695,
		3696, 5, 3, 0, 0, 3696, 3697, 3, 238, 119, 0, 3697, 3698, 5, 324, 0, 0,
		3698, 3699, 3, 1340, 670, 0, 3699, 3700, 3, 340, 170, 0, 3700, 3746, 1,
		0, 0, 0, 3701, 3702, 5, 46, 0, 0, 3702, 3703, 5, 63, 0, 0, 3703, 3704,
		5, 92, 0, 0, 3704, 3705, 5, 220, 0, 0, 3705, 3706, 5, 77, 0, 0, 3706, 3707,
		5, 389, 0, 0, 3707, 3708, 3, 1336, 668, 0, 3708, 3709, 5, 2, 0, 0, 3709,
		3710, 3, 176, 88, 0, 3710, 3711, 5, 3, 0, 0, 3711, 3712, 3, 238, 119, 0,
		3712, 3713, 5, 324, 0, 0, 3713, 3714, 3, 1340, 670, 0, 3714, 3715, 3, 340,
		170, 0, 3715, 3746, 1, 0, 0, 0, 3716, 3717, 5, 46, 0, 0, 3717, 3718, 5,
		63, 0, 0, 3718, 3719, 5, 92, 0, 0, 3719, 3720, 3, 1336, 668, 0, 3720, 3721,
		5, 278, 0, 0, 3721, 3722, 5, 268, 0, 0, 3722, 3723, 3, 1336, 668, 0, 3723,
		3724, 3, 178, 89, 0, 3724, 3725, 3, 128, 64, 0, 3725, 3726, 5, 324, 0,
		0, 3726, 3727, 3, 1340, 670, 0, 3727, 3728, 3, 340, 170, 0, 3728, 3746,
		1, 0, 0, 0, 3729, 3730, 5, 46, 0, 0, 3730, 3731, 5, 63, 0, 0, 3731, 3732,
		5, 92, 0, 0, 3732, 3733, 5, 220, 0, 0, 3733, 3734, 5, 77, 0, 0, 3734, 3735,
		5, 389, 0, 0, 3735, 3736, 3, 1336, 668, 0, 3736, 3737, 5, 278, 0, 0, 3737,
		3738, 5, 268, 0, 0, 3738, 3739, 3, 1336, 668, 0, 3739, 3740, 3, 178, 89,
		0, 3740, 3741, 3, 128, 64, 0, 3741, 3742, 5, 324, 0, 0, 3742, 3743, 3,
		1340, 670, 0, 3743, 3744, 3, 340, 170, 0, 3744, 3746, 1, 0, 0, 0, 3745,
		3689, 1, 0, 0, 0, 3745, 3701, 1, 0, 0, 0, 3745, 3716, 1, 0, 0, 0, 3745,
		3729, 1, 0, 0, 0, 3746, 367, 1, 0, 0, 0, 3747, 3748, 5, 444, 0, 0, 3748,
		3749, 5, 63, 0, 0, 3749, 3750, 5, 316, 0, 0, 3750, 3751, 3, 1340, 670,
		0, 3751, 3752, 3, 372, 186, 0, 3752, 3753, 5, 64, 0, 0, 3753, 3754, 5,
		324, 0, 0, 3754, 3755, 3, 1340, 670, 0, 3755, 3756, 5, 71, 0, 0, 3756,
		3757, 3, 1340, 670, 0, 3757, 3758, 3, 340, 170, 0, 3758, 369, 1, 0, 0,
		0, 3759, 3760, 5, 74, 0, 0, 3760, 3763, 5, 94, 0, 0, 3761, 3763, 5, 59,
		0, 0, 3762, 3759, 1, 0, 0, 0, 3762, 3761, 1, 0, 0, 0, 3763, 371, 1, 0,
		0, 0, 3764, 3765, 3, 370, 185, 0, 3765, 3766, 5, 2, 0, 0, 3766, 3767, 3,
		1076, 538, 0, 3767, 3768, 5, 3, 0, 0, 3768, 3771, 1, 0, 0, 0, 3769, 3771,
		1, 0, 0, 0, 3770, 3764, 1, 0, 0, 0, 3770, 3769, 1, 0, 0, 0, 3771, 373,
		1, 0, 0, 0, 3772, 3773, 5, 46, 0, 0, 3773, 3774, 5, 99, 0, 0, 3774, 3775,
		5, 248, 0, 0, 3775, 3776, 5, 62, 0, 0, 3776, 3777, 3, 376, 188, 0, 3777,
		3778, 5, 324, 0, 0, 3778, 3779, 3, 1340, 670, 0, 3779, 3780, 3, 340, 170,
		0, 3780, 3794, 1, 0, 0, 0, 3781, 3782, 5, 46, 0, 0, 3782, 3783, 5, 99,
		0, 0, 3783, 3784, 5, 248, 0, 0, 3784, 3785, 5, 220, 0, 0, 3785, 3786, 5,
		77, 0, 0, 3786, 3787, 5, 389, 0, 0, 3787, 3788, 5, 62, 0, 0, 3788, 3789,
		3, 376, 188, 0, 3789, 3790, 5, 324, 0, 0, 3790, 3791, 3, 1340, 670, 0,
		3791, 3792, 3, 340, 170, 0, 3792, 3794, 1, 0, 0, 0, 3793, 3772, 1, 0, 0,
		0, 3793, 3781, 1, 0, 0, 0, 3794, 375, 1, 0, 0, 0, 3795, 3798, 3, 1368,
		684, 0, 3796, 3798, 5, 99, 0, 0, 3797, 3795, 1, 0, 0, 0, 3797, 3796, 1,
		0, 0, 0, 3798, 377, 1, 0, 0, 0, 3799, 3800, 5, 191, 0, 0, 3800, 3801, 5,
		99, 0, 0, 3801, 3802, 5, 248, 0, 0, 3802, 3803, 5, 62, 0, 0, 3803, 3804,
		3, 376, 188, 0, 3804, 3805, 5, 324, 0, 0, 3805, 3806, 3, 1340, 670, 0,
		3806, 3818, 1, 0, 0, 0, 3807, 3808, 5, 191, 0, 0, 3808, 3809, 5, 99, 0,
		0, 3809, 3810, 5, 248, 0, 0, 3810, 3811, 5, 220, 0, 0, 3811, 3812, 5, 389,
		0, 0, 3812, 3813, 5, 62, 0, 0, 3813, 3814, 3, 376, 188, 0, 3814, 3815,
		5, 324, 0, 0, 3815, 3816, 3, 1340, 670, 0, 3816, 3818, 1, 0, 0, 0, 3817,
		3799, 1, 0, 0, 0, 3817, 3807, 1, 0, 0, 0, 3818, 379, 1, 0, 0, 0, 3819,
		3820, 5, 138, 0, 0, 3820, 3821, 5, 99, 0, 0, 3821, 3822, 5, 248, 0, 0,
		3822, 3823, 5, 62, 0, 0, 3823, 3824, 3, 376, 188, 0, 3824, 3825, 5, 324,
		0, 0, 3825, 3826, 3, 1340, 670, 0, 3826, 3827, 3, 344, 172, 0, 3827, 381,
		1, 0, 0, 0, 3828, 3829, 5, 46, 0, 0, 3829, 3830, 5, 445, 0, 0, 3830, 3831,
		3, 1340, 670, 0, 3831, 3832, 5, 80, 0, 0, 3832, 3833, 3, 1336, 668, 0,
		3833, 3834, 3, 394, 197, 0, 3834, 3835, 3, 396, 198, 0, 3835, 3836, 3,
		390, 195, 0, 3836, 3837, 3, 386, 193, 0, 3837, 3838, 3, 388, 194, 0, 3838,
		383, 1, 0, 0, 0, 3839, 3840, 5, 138, 0, 0, 3840, 3841, 5, 445, 0, 0, 3841,
		3842, 3, 1340, 670, 0, 3842, 3843, 5, 80, 0, 0, 3843, 3844, 3, 1336, 668,
		0, 3844, 3845, 3, 392, 196, 0, 3845, 3846, 3, 386, 193, 0, 3846, 3847,
		3, 388, 194, 0, 3847, 385, 1, 0, 0, 0, 3848, 3849, 5, 100, 0, 0, 3849,
		3850, 5, 2, 0, 0, 3850, 3851, 3, 1162, 581, 0, 3851, 3852, 5, 3, 0, 0,
		3852, 3855, 1, 0, 0, 0, 3853, 3855, 1, 0, 0, 0, 3854, 3848, 1, 0, 0, 0,
		3854, 3853, 1, 0, 0, 0, 3855, 387, 1, 0, 0, 0, 3856, 3857, 5, 105, 0, 0,
		3857, 3858, 5, 42, 0, 0, 3858, 3859, 5, 2, 0, 0, 3859, 3860, 3, 1162, 581,
		0, 3860, 3861, 5, 3, 0, 0, 3861, 3864, 1, 0, 0, 0, 3862, 3864, 1, 0, 0,
		0, 3863, 3856, 1, 0, 0, 0, 3863, 3862, 1, 0, 0, 0, 3864, 389, 1, 0, 0,
		0, 3865, 3866, 5, 94, 0, 0, 3866, 3869, 3, 1370, 685, 0, 3867, 3869, 1,
		0, 0, 0, 3868, 3865, 1, 0, 0, 0, 3868, 3867, 1, 0, 0, 0, 3869, 391, 1,
		0, 0, 0, 3870, 3871, 5, 94, 0, 0, 3871, 3874, 3, 1370, 685, 0, 3872, 3874,
		1, 0, 0, 0, 3873, 3870, 1, 0, 0, 0, 3873, 3872, 1, 0, 0, 0, 3874, 393,
		1, 0, 0, 0, 3875, 3876, 5, 36, 0, 0, 3876, 3879, 3, 1382, 691, 0, 3877,
		3879, 1, 0, 0, 0, 3878, 3875, 1, 0, 0, 0, 3878, 3877, 1, 0, 0, 0, 3879,
		395, 1, 0, 0, 0, 3880, 3881, 5, 62, 0, 0, 3881, 3884, 3, 398, 199, 0, 3882,
		3884, 1, 0, 0, 0, 3883, 3880, 1, 0, 0, 0, 3883, 3882, 1, 0, 0, 0, 3884,
		397, 1, 0, 0, 0, 3885, 3886, 7, 17, 0, 0, 3886, 399, 1, 0, 0, 0, 3887,
		3888, 5, 46, 0, 0, 3888, 3889, 5, 131, 0, 0, 3889, 3890, 5, 446, 0, 0,
		3890, 3891, 3, 1340, 670, 0, 3891, 3892, 5, 353, 0, 0, 3892, 3893, 3, 402,
		201, 0, 3893, 3894, 5, 215, 0, 0, 3894, 3895, 3, 300, 150, 0, 3895, 401,
		1, 0, 0, 0, 3896, 3897, 7, 18, 0, 0, 3897, 403, 1, 0, 0, 0, 3898, 3899,
		5, 46, 0, 0, 3899, 3900, 5, 350, 0, 0, 3900, 3901, 3, 1340, 670, 0, 3901,
		3902, 3, 406, 203, 0, 3902, 3903, 3, 408, 204, 0, 3903, 3904, 5, 80, 0,
		0, 3904, 3905, 3, 1336, 668, 0, 3905, 3906, 3, 412, 206, 0, 3906, 3907,
		3, 424, 212, 0, 3907, 3908, 3, 430, 215, 0, 3908, 3909, 5, 202, 0, 0, 3909,
		3910, 3, 432, 216, 0, 3910, 3911, 3, 1346, 673, 0, 3911, 3912, 5, 2, 0,
		0, 3912, 3913, 3, 434, 217, 0, 3913, 3914, 5, 3, 0, 0, 3914, 3937, 1, 0,
		0, 0, 3915, 3916, 5, 46, 0, 0, 3916, 3917, 5, 45, 0, 0, 3917, 3918, 5,
		350, 0, 0, 3918, 3919, 3, 1340, 670, 0, 3919, 3920, 5, 135, 0, 0, 3920,
		3921, 3, 408, 204, 0, 3921, 3922, 5, 80, 0, 0, 3922, 3923, 3, 1336, 668,
		0, 3923, 3924, 3, 438, 219, 0, 3924, 3925, 3, 440, 220, 0, 3925, 3926,
		5, 62, 0, 0, 3926, 3927, 5, 192, 0, 0, 3927, 3928, 5, 407, 0, 0, 3928,
		3929, 3, 430, 215, 0, 3929, 3930, 5, 202, 0, 0, 3930, 3931, 3, 432, 216,
		0, 3931, 3932, 3, 1346, 673, 0, 3932, 3933, 5, 2, 0, 0, 3933, 3934, 3,
		434, 217, 0, 3934, 3935, 5, 3, 0, 0, 3935, 3937, 1, 0, 0, 0, 3936, 3898,
		1, 0, 0, 0, 3936, 3915, 1, 0, 0, 0, 3937, 405, 1, 0, 0, 0, 3938, 3943,
		5, 145, 0, 0, 3939, 3943, 5, 135, 0, 0, 3940, 3941, 5, 233, 0, 0, 3941,
		3943, 5, 268, 0, 0, 3942, 3938, 1, 0, 0, 0, 3942, 3939, 1, 0, 0, 0, 3942,
		3940, 1, 0, 0, 0, 3943, 407, 1, 0, 0, 0, 3944, 3949, 3, 410, 205, 0, 3945,
		3946, 5, 82, 0, 0, 3946, 3948, 3, 410, 205, 0, 3947, 3945, 1, 0, 0, 0,
		3948, 3951, 1, 0, 0, 0, 3949, 3947, 1, 0, 0, 0, 3949, 3950, 1, 0, 0, 0,
		3950, 409, 1, 0, 0, 0, 3951, 3949, 1, 0, 0, 0, 3952, 3960, 5, 232, 0, 0,
		3953, 3960, 5, 182, 0, 0, 3954, 3960, 5, 362, 0, 0, 3955, 3956, 5, 362,
		0, 0, 3956, 3957, 5, 268, 0, 0, 3957, 3960, 3, 216, 108, 0, 3958, 3960,
		5, 351, 0, 0, 3959, 3952, 1, 0, 0, 0, 3959, 3953, 1, 0, 0, 0, 3959, 3954,
		1, 0, 0, 0, 3959, 3955, 1, 0, 0, 0, 3959, 3958, 1, 0, 0, 0, 3960, 411,
		1, 0, 0, 0, 3961, 3962, 5, 447, 0, 0, 3962, 3965, 3, 414, 207, 0, 3963,
		3965, 1, 0, 0, 0, 3964, 3961, 1, 0, 0, 0, 3964, 3963, 1, 0, 0, 0, 3965,
		413, 1, 0, 0, 0, 3966, 3968, 3, 416, 208, 0, 3967, 3966, 1, 0, 0, 0, 3968,
		3969, 1, 0, 0, 0, 3969, 3967, 1, 0, 0, 0, 3969, 3970, 1, 0, 0, 0, 3970,
		415, 1, 0, 0, 0, 3971, 3972, 3, 418, 209, 0, 3972, 3973, 3, 420, 210, 0,
		3973, 3974, 3, 834, 417, 0, 3974, 3975, 3, 422, 211, 0, 3975, 417, 1, 0,
		0, 0, 3976, 3977, 7, 19, 0, 0, 3977, 419, 1, 0, 0, 0, 3978, 3979, 7, 20,
		0, 0, 3979, 421, 1, 0, 0, 0, 3980, 3981, 3, 1372, 686, 0, 3981, 423, 1,
		0, 0, 0, 3982, 3983, 5, 62, 0, 0, 3983, 3984, 3, 426, 213, 0, 3984, 3985,
		3, 428, 214, 0, 3985, 3988, 1, 0, 0, 0, 3986, 3988, 1, 0, 0, 0, 3987, 3982,
		1, 0, 0, 0, 3987, 3986, 1, 0, 0, 0, 3988, 425, 1, 0, 0, 0, 3989, 3992,
		5, 192, 0, 0, 3990, 3992, 1, 0, 0, 0, 3991, 3989, 1, 0, 0, 0, 3991, 3990,
		1, 0, 0, 0, 3992, 427, 1, 0, 0, 0, 3993, 3994, 7, 21, 0, 0, 3994, 429,
		1, 0, 0, 0, 3995, 3996, 5, 102, 0, 0, 3996, 3997, 5, 2, 0, 0, 3997, 3998,
		3, 1162, 581, 0, 3998, 3999, 5, 3, 0, 0, 3999, 4002, 1, 0, 0, 0, 4000,
		4002, 1, 0, 0, 0, 4001, 3995, 1, 0, 0, 0, 4001, 4000, 1, 0, 0, 0, 4002,
		431, 1, 0, 0, 0, 4003, 4004, 7, 22, 0, 0, 4004, 433, 1, 0, 0, 0, 4005,
		4008, 3, 436, 218, 0, 4006, 4008, 1, 0, 0, 0, 4007, 4005, 1, 0, 0, 0, 4007,
		4006, 1, 0, 0, 0, 4008, 4013, 1, 0, 0, 0, 4009, 4010, 5, 6, 0, 0, 4010,
		4012, 3, 436, 218, 0, 4011, 4009, 1, 0, 0, 0, 4012, 4015, 1, 0, 0, 0, 4013,
		4011, 1, 0, 0, 0, 4013, 4014, 1, 0, 0, 0, 4014, 435, 1, 0, 0, 0, 4015,
		4013, 1, 0, 0, 0, 4016, 4021, 3, 1356, 678, 0, 4017, 4021, 3, 1354, 677,
		0, 4018, 4021, 3, 1358, 679, 0, 4019, 4021, 3, 1380, 690, 0, 4020, 4016,
		1, 0, 0, 0, 4020, 4017, 1, 0, 0, 0, 4020, 4018, 1, 0, 0, 0, 4020, 4019,
		1, 0, 0, 0, 4021, 437, 1, 0, 0, 0, 4022, 4023, 5, 64, 0, 0, 4023, 4026,
		3, 1336, 668, 0, 4024, 4026, 1, 0, 0, 0, 4025, 4022, 1, 0, 0, 0, 4025,
		4024, 1, 0, 0, 0, 4026, 439, 1, 0, 0, 0, 4027, 4029, 3, 442, 221, 0, 4028,
		4027, 1, 0, 0, 0, 4029, 4032, 1, 0, 0, 0, 4030, 4028, 1, 0, 0, 0, 4030,
		4031, 1, 0, 0, 0, 4031, 441, 1, 0, 0, 0, 4032, 4030, 1, 0, 0, 0, 4033,
		4034, 5, 77, 0, 0, 4034, 4045, 5, 54, 0, 0, 4035, 4045, 5, 54, 0, 0, 4036,
		4037, 5, 69, 0, 0, 4037, 4045, 5, 221, 0, 0, 4038, 4039, 5, 69, 0, 0, 4039,
		4045, 5, 180, 0, 0, 4040, 4041, 5, 77, 0, 0, 4041, 4045, 5, 364, 0, 0,
		4042, 4043, 5, 262, 0, 0, 4043, 4045, 5, 228, 0, 0, 4044, 4033, 1, 0, 0,
		0, 4044, 4035, 1, 0, 0, 0, 4044, 4036, 1, 0, 0, 0, 4044, 4038, 1, 0, 0,
		0, 4044, 4040, 1, 0, 0, 0, 4044, 4042, 1, 0, 0, 0, 4045, 443, 1, 0, 0,
		0, 4046, 4047, 5, 46, 0, 0, 4047, 4048, 5, 198, 0, 0, 4048, 4049, 5, 350,
		0, 0, 4049, 4050, 3, 1340, 670, 0, 4050, 4051, 5, 80, 0, 0, 4051, 4052,
		3, 1380, 690, 0, 4052, 4053, 5, 202, 0, 0, 4053, 4054, 3, 432, 216, 0,
		4054, 4055, 3, 1346, 673, 0, 4055, 4056, 5, 2, 0, 0, 4056, 4057, 5, 3,
		0, 0, 4057, 4073, 1, 0, 0, 0, 4058, 4059, 5, 46, 0, 0, 4059, 4060, 5, 198,
		0, 0, 4060, 4061, 5, 350, 0, 0, 4061, 4062, 3, 1340, 670, 0, 4062, 4063,
		5, 80, 0, 0, 4063, 4064, 3, 1380, 690, 0, 4064, 4065, 5, 102, 0, 0, 4065,
		4066, 3, 446, 223, 0, 4066, 4067, 5, 202, 0, 0, 4067, 4068, 3, 432, 216,
		0, 4068, 4069, 3, 1346, 673, 0, 4069, 4070, 5, 2, 0, 0, 4070, 4071, 5,
		3, 0, 0, 4071, 4073, 1, 0, 0, 0, 4072, 4046, 1, 0, 0, 0, 4072, 4058, 1,
		0, 0, 0, 4073, 445, 1, 0, 0, 0, 4074, 4079, 3, 448, 224, 0, 4075, 4076,
		5, 33, 0, 0, 4076, 4078, 3, 448, 224, 0, 4077, 4075, 1, 0, 0, 0, 4078,
		4081, 1, 0, 0, 0, 4079, 4077, 1, 0, 0, 0, 4079, 4080, 1, 0, 0, 0, 4080,
		447, 1, 0, 0, 0, 4081, 4079, 1, 0, 0, 0, 4082, 4083, 3, 1372, 686, 0, 4083,
		4084, 5, 68, 0, 0, 4084, 4085, 5, 2, 0, 0, 4085, 4086, 3, 450, 225, 0,
		4086, 4087, 5, 3, 0, 0, 4087, 449, 1, 0, 0, 0, 4088, 4093, 3, 1358, 679,
		0, 4089, 4090, 5, 6, 0, 0, 4090, 4092, 3, 1358, 679, 0, 4091, 4089, 1,
		0, 0, 0, 4092, 4095, 1, 0, 0, 0, 4093, 4091, 1, 0, 0, 0, 4093, 4094, 1,
		0, 0, 0, 4094, 451, 1, 0, 0, 0, 4095, 4093, 1, 0, 0, 0, 4096, 4097, 5,
		138, 0, 0, 4097, 4098, 5, 198, 0, 0, 4098, 4099, 5, 350, 0, 0, 4099, 4100,
		3, 1340, 670, 0, 4100, 4101, 3, 454, 227, 0, 4101, 453, 1, 0, 0, 0, 4102,
		4109, 5, 193, 0, 0, 4103, 4104, 5, 193, 0, 0, 4104, 4109, 5, 305, 0, 0,
		4105, 4106, 5, 193, 0, 0, 4106, 4109, 5, 139, 0, 0, 4107, 4109, 5, 186,
		0, 0, 4108, 4102, 1, 0, 0, 0, 4108, 4103, 1, 0, 0, 0, 4108, 4105, 1, 0,
		0, 0, 4108, 4107, 1, 0, 0, 0, 4109, 455, 1, 0, 0, 0, 4110, 4111, 5, 46,
		0, 0, 4111, 4112, 5, 140, 0, 0, 4112, 4113, 3, 524, 262, 0, 4113, 4114,
		5, 42, 0, 0, 4114, 4115, 5, 2, 0, 0, 4115, 4116, 3, 1162, 581, 0, 4116,
		4117, 5, 3, 0, 0, 4117, 4118, 3, 440, 220, 0, 4118, 457, 1, 0, 0, 0, 4119,
		4120, 5, 46, 0, 0, 4120, 4121, 3, 618, 309, 0, 4121, 4122, 5, 136, 0, 0,
		4122, 4123, 3, 1346, 673, 0, 4123, 4124, 3, 646, 323, 0, 4124, 4125, 3,
		460, 230, 0, 4125, 4226, 1, 0, 0, 0, 4126, 4127, 5, 46, 0, 0, 4127, 4128,
		3, 618, 309, 0, 4128, 4129, 5, 136, 0, 0, 4129, 4130, 3, 1346, 673, 0,
		4130, 4131, 3, 468, 234, 0, 4131, 4226, 1, 0, 0, 0, 4132, 4133, 5, 46,
		0, 0, 4133, 4134, 5, 271, 0, 0, 4134, 4135, 3, 684, 342, 0, 4135, 4136,
		3, 460, 230, 0, 4136, 4226, 1, 0, 0, 0, 4137, 4138, 5, 46, 0, 0, 4138,
		4139, 5, 353, 0, 0, 4139, 4140, 3, 524, 262, 0, 4140, 4141, 3, 460, 230,
		0, 4141, 4226, 1, 0, 0, 0, 4142, 4143, 5, 46, 0, 0, 4143, 4144, 5, 353,
		0, 0, 4144, 4226, 3, 524, 262, 0, 4145, 4146, 5, 46, 0, 0, 4146, 4147,
		5, 353, 0, 0, 4147, 4148, 3, 524, 262, 0, 4148, 4149, 5, 36, 0, 0, 4149,
		4150, 5, 2, 0, 0, 4150, 4151, 3, 1098, 549, 0, 4151, 4152, 5, 3, 0, 0,
		4152, 4226, 1, 0, 0, 0, 4153, 4154, 5, 46, 0, 0, 4154, 4155, 5, 353, 0,
		0, 4155, 4156, 3, 524, 262, 0, 4156, 4157, 5, 36, 0, 0, 4157, 4158, 5,
		196, 0, 0, 4158, 4159, 5, 2, 0, 0, 4159, 4160, 3, 474, 237, 0, 4160, 4161,
		5, 3, 0, 0, 4161, 4226, 1, 0, 0, 0, 4162, 4163, 5, 46, 0, 0, 4163, 4164,
		5, 353, 0, 0, 4164, 4165, 3, 524, 262, 0, 4165, 4166, 5, 36, 0, 0, 4166,
		4167, 5, 292, 0, 0, 4167, 4168, 3, 460, 230, 0, 4168, 4226, 1, 0, 0, 0,
		4169, 4170, 5, 46, 0, 0, 4170, 4171, 5, 348, 0, 0, 4171, 4172, 5, 318,
		0, 0, 4172, 4173, 5, 276, 0, 0, 4173, 4174, 3, 524, 262, 0, 4174, 4175,
		3, 460, 230, 0, 4175, 4226, 1, 0, 0, 0, 4176, 4177, 5, 46, 0, 0, 4177,
		4178, 5, 348, 0, 0, 4178, 4179, 5, 318, 0, 0, 4179, 4180, 5, 185, 0, 0,
		4180, 4181, 3, 524, 262, 0, 4181, 4182, 3, 460, 230, 0, 4182, 4226, 1,
		0, 0, 0, 4183, 4184, 5, 46, 0, 0, 4184, 4185, 5, 348, 0, 0, 4185, 4186,
		5, 318, 0, 0, 4186, 4187, 5, 346, 0, 0, 4187, 4188, 3, 524, 262, 0, 4188,
		4189, 3, 460, 230, 0, 4189, 4226, 1, 0, 0, 0, 4190, 4191, 5, 46, 0, 0,
		4191, 4192, 5, 348, 0, 0, 4192, 4193, 5, 318, 0, 0, 4193, 4194, 5, 163,
		0, 0, 4194, 4195, 3, 524, 262, 0, 4195, 4196, 3, 460, 230, 0, 4196, 4226,
		1, 0, 0, 0, 4197, 4198, 5, 46, 0, 0, 4198, 4199, 5, 108, 0, 0, 4199, 4200,
		3, 524, 262, 0, 4200, 4201, 3, 460, 230, 0, 4201, 4226, 1, 0, 0, 0, 4202,
		4203, 5, 46, 0, 0, 4203, 4204, 5, 108, 0, 0, 4204, 4205, 5, 220, 0, 0,
		4205, 4206, 5, 77, 0, 0, 4206, 4207, 5, 389, 0, 0, 4207, 4208, 3, 524,
		262, 0, 4208, 4209, 3, 460, 230, 0, 4209, 4226, 1, 0, 0, 0, 4210, 4211,
		5, 46, 0, 0, 4211, 4212, 5, 108, 0, 0, 4212, 4213, 3, 524, 262, 0, 4213,
		4214, 5, 64, 0, 0, 4214, 4215, 3, 524, 262, 0, 4215, 4226, 1, 0, 0, 0,
		4216, 4217, 5, 46, 0, 0, 4217, 4218, 5, 108, 0, 0, 4218, 4219, 5, 220,
		0, 0, 4219, 4220, 5, 77, 0, 0, 4220, 4221, 5, 389, 0, 0, 4221, 4222, 3,
		524, 262, 0, 4222, 4223, 5, 64, 0, 0, 4223, 4224, 3, 524, 262, 0, 4224,
		4226, 1, 0, 0, 0, 4225, 4119, 1, 0, 0, 0, 4225, 4126, 1, 0, 0, 0, 4225,
		4132, 1, 0, 0, 0, 4225, 4137, 1, 0, 0, 0, 4225, 4142, 1, 0, 0, 0, 4225,
		4145, 1, 0, 0, 0, 4225, 4153, 1, 0, 0, 0, 4225, 4162, 1, 0, 0, 0, 4225,
		4169, 1, 0, 0, 0, 4225, 4176, 1, 0, 0, 0, 4225, 4183, 1, 0, 0, 0, 4225,
		4190, 1, 0, 0, 0, 4225, 4197, 1, 0, 0, 0, 4225, 4202, 1, 0, 0, 0, 4225,
		4210, 1, 0, 0, 0, 4225, 4216, 1, 0, 0, 0, 4226, 459, 1, 0, 0, 0, 4227,
		4228, 5, 2, 0, 0, 4228, 4229, 3, 462, 231, 0, 4229, 4230, 5, 3, 0, 0, 4230,
		461, 1, 0, 0, 0, 4231, 4236, 3, 464, 232, 0, 4232, 4233, 5, 6, 0, 0, 4233,
		4235, 3, 464, 232, 0, 4234, 4232, 1, 0, 0, 0, 4235, 4238, 1, 0, 0, 0, 4236,
		4234, 1, 0, 0, 0, 4236, 4237, 1, 0, 0, 0, 4237, 463, 1, 0, 0, 0, 4238,
		4236, 1, 0, 0, 0, 4239, 4242, 3, 1380, 690, 0, 4240, 4241, 5, 10, 0, 0,
		4241, 4243, 3, 466, 233, 0, 4242, 4240, 1, 0, 0, 0, 4242, 4243, 1, 0, 0,
		0, 4243, 465, 1, 0, 0, 0, 4244, 4251, 3, 640, 320, 0, 4245, 4251, 3, 1392,
		696, 0, 4246, 4251, 3, 1276, 638, 0, 4247, 4251, 3, 292, 146, 0, 4248,
		4251, 3, 1358, 679, 0, 4249, 4251, 5, 400, 0, 0, 4250, 4244, 1, 0, 0, 0,
		4250, 4245, 1, 0, 0, 0, 4250, 4246, 1, 0, 0, 0, 4250, 4247, 1, 0, 0, 0,
		4250, 4248, 1, 0, 0, 0, 4250, 4249, 1, 0, 0, 0, 4251, 467, 1, 0, 0, 0,
		4252, 4253, 5, 2, 0, 0, 4253, 4254, 3, 470, 235, 0, 4254, 4255, 5, 3, 0,
		0, 4255, 469, 1, 0, 0, 0, 4256, 4261, 3, 472, 236, 0, 4257, 4258, 5, 6,
		0, 0, 4258, 4260, 3, 472, 236, 0, 4259, 4257, 1, 0, 0, 0, 4260, 4263, 1,
		0, 0, 0, 4261, 4259, 1, 0, 0, 0, 4261, 4262, 1, 0, 0, 0, 4262, 471, 1,
		0, 0, 0, 4263, 4261, 1, 0, 0, 0, 4264, 4265, 3, 1382, 691, 0, 4265, 4266,
		5, 10, 0, 0, 4266, 4267, 3, 466, 233, 0, 4267, 473, 1, 0, 0, 0, 4268, 4271,
		3, 476, 238, 0, 4269, 4271, 1, 0, 0, 0, 4270, 4268, 1, 0, 0, 0, 4270, 4269,
		1, 0, 0, 0, 4271, 475, 1, 0, 0, 0, 4272, 4277, 3, 1358, 679, 0, 4273, 4274,
		5, 6, 0, 0, 4274, 4276, 3, 1358, 679, 0, 4275, 4273, 1, 0, 0, 0, 4276,
		4279, 1, 0, 0, 0, 4277, 4275, 1, 0, 0, 0, 4277, 4278, 1, 0, 0, 0, 4278,
		477, 1, 0, 0, 0, 4279, 4277, 1, 0, 0, 0, 4280, 4281, 5, 138, 0, 0, 4281,
		4282, 5, 353, 0, 0, 4282, 4283, 3, 524, 262, 0, 4283, 4284, 5, 133, 0,
		0, 4284, 4285, 5, 450, 0, 0, 4285, 4286, 3, 480, 240, 0, 4286, 4287, 3,
		1358, 679, 0, 4287, 4318, 1, 0, 0, 0, 4288, 4289, 5, 138, 0, 0, 4289, 4290,
		5, 353, 0, 0, 4290, 4291, 3, 524, 262, 0, 4291, 4292, 5, 133, 0, 0, 4292,
		4293, 5, 450, 0, 0, 4293, 4294, 3, 480, 240, 0, 4294, 4295, 3, 1358, 679,
		0, 4295, 4296, 5, 145, 0, 0, 4296, 4297, 3, 1358, 679, 0, 4297, 4318, 1,
		0, 0, 0, 4298, 4299, 5, 138, 0, 0, 4299, 4300, 5, 353, 0, 0, 4300, 4301,
		3, 524, 262, 0, 4301, 4302, 5, 133, 0, 0, 4302, 4303, 5, 450, 0, 0, 4303,
		4304, 3, 480, 240, 0, 4304, 4305, 3, 1358, 679, 0, 4305, 4306, 5, 135,
		0, 0, 4306, 4307, 3, 1358, 679, 0, 4307, 4318, 1, 0, 0, 0, 4308, 4309,
		5, 138, 0, 0, 4309, 4310, 5, 353, 0, 0, 4310, 4311, 3, 524, 262, 0, 4311,
		4312, 5, 302, 0, 0, 4312, 4313, 5, 450, 0, 0, 4313, 4314, 3, 1358, 679,
		0, 4314, 4315, 5, 94, 0, 0, 4315, 4316, 3, 1358, 679, 0, 4316, 4318, 1,
		0, 0, 0, 4317, 4280, 1, 0, 0, 0, 4317, 4288, 1, 0, 0, 0, 4317, 4298, 1,
		0, 0, 0, 4317, 4308, 1, 0, 0, 0, 4318, 479, 1, 0, 0, 0, 4319, 4320, 5,
		220, 0, 0, 4320, 4321, 5, 77, 0, 0, 4321, 4324, 5, 389, 0, 0, 4322, 4324,
		1, 0, 0, 0, 4323, 4319, 1, 0, 0, 0, 4323, 4322, 1, 0, 0, 0, 4324, 481,
		1, 0, 0, 0, 4325, 4326, 5, 46, 0, 0, 4326, 4327, 5, 271, 0, 0, 4327, 4328,
		5, 156, 0, 0, 4328, 4329, 3, 524, 262, 0, 4329, 4330, 3, 488, 244, 0, 4330,
		4331, 5, 62, 0, 0, 4331, 4332, 5, 353, 0, 0, 4332, 4333, 3, 1118, 559,
		0, 4333, 4334, 5, 100, 0, 0, 4334, 4335, 3, 1340, 670, 0, 4335, 4336, 3,
		490, 245, 0, 4336, 4337, 5, 36, 0, 0, 4337, 4338, 3, 484, 242, 0, 4338,
		483, 1, 0, 0, 0, 4339, 4344, 3, 486, 243, 0, 4340, 4341, 5, 6, 0, 0, 4341,
		4343, 3, 486, 243, 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, 485, 1, 0, 0, 0, 4346,
		4344, 1, 0, 0, 0, 4347, 4348, 5, 271, 0, 0, 4348, 4349, 3, 1356, 678, 0,
		4349, 4350, 3, 684, 342, 0, 4350, 4351, 3, 492, 246, 0, 4351, 4352, 3,
		494, 247, 0, 4352, 4373, 1, 0, 0, 0, 4353, 4354, 5, 271, 0, 0, 4354, 4355,
		3, 1356, 678, 0, 4355, 4356, 3, 688, 344, 0, 4356, 4357, 3, 492, 246, 0,
		4357, 4358, 3, 494, 247, 0, 4358, 4373, 1, 0, 0, 0, 4359, 4360, 5, 211,
		0, 0, 4360, 4361, 3, 1356, 678, 0, 4361, 4362, 3, 626, 313, 0, 4362, 4373,
		1, 0, 0, 0, 4363, 4364, 5, 211, 0, 0, 4364, 4365, 3, 1356, 678, 0, 4365,
		4366, 5, 2, 0, 0, 4366, 4367, 3, 1286, 643, 0, 4367, 4368, 5, 3, 0, 0,
		4368, 4369, 3, 626, 313, 0, 4369, 4373, 1, 0, 0, 0, 4370, 4371, 5, 338,
		0, 0, 4371, 4373, 3, 1118, 559, 0, 4372, 4347, 1, 0, 0, 0, 4372, 4353,
		1, 0, 0, 0, 4372, 4359, 1, 0, 0, 0, 4372, 4363, 1, 0, 0, 0, 4372, 4370,
		1, 0, 0, 0, 4373, 487, 1, 0, 0, 0, 4374, 4377, 5, 53, 0, 0, 4375, 4377,
		1, 0, 0, 0, 4376, 4374, 1, 0, 0, 0, 4376, 4375, 1, 0, 0, 0, 4377, 489,
		1, 0, 0, 0, 4378, 4379, 5, 206, 0, 0, 4379, 4382, 3, 524, 262, 0, 4380,
		4382, 1, 0, 0, 0, 4381, 4378, 1, 0, 0, 0, 4381, 4380, 1, 0, 0, 0, 4382,
		491, 1, 0, 0, 0, 4383, 4384, 5, 62, 0, 0, 4384, 4391, 5, 318, 0, 0, 4385,
		4386, 5, 62, 0, 0, 4386, 4387, 5, 83, 0, 0, 4387, 4388, 5, 147, 0, 0, 4388,
		4391, 3, 524, 262, 0, 4389, 4391, 1, 0, 0, 0, 4390, 4383, 1, 0, 0, 0, 4390,
		4385, 1, 0, 0, 0, 4390, 4389, 1, 0, 0, 0, 4391, 493, 1, 0, 0, 0, 4392,
		4395, 5, 295, 0, 0, 4393, 4395, 1, 0, 0, 0, 4394, 4392, 1, 0, 0, 0, 4394,
		4393, 1, 0, 0, 0, 4395, 495, 1, 0, 0, 0, 4396, 4397, 5, 46, 0, 0, 4397,
		4398, 5, 271, 0, 0, 4398, 4399, 5, 206, 0, 0, 4399, 4400, 3, 524, 262,
		0, 4400, 4401, 5, 100, 0, 0, 4401, 4402, 3, 1340, 670, 0, 4402, 497, 1,
		0, 0, 0, 4403, 4404, 5, 138, 0, 0, 4404, 4405, 5, 271, 0, 0, 4405, 4406,
		5, 206, 0, 0, 4406, 4407, 3, 524, 262, 0, 4407, 4408, 5, 100, 0, 0, 4408,
		4409, 3, 1340, 670, 0, 4409, 4410, 5, 133, 0, 0, 4410, 4411, 3, 484, 242,
		0, 4411, 4422, 1, 0, 0, 0, 4412, 4413, 5, 138, 0, 0, 4413, 4414, 5, 271,
		0, 0, 4414, 4415, 5, 206, 0, 0, 4415, 4416, 3, 524, 262, 0, 4416, 4417,
		5, 100, 0, 0, 4417, 4418, 3, 1340, 670, 0, 4418, 4419, 5, 191, 0, 0, 4419,
		4420, 3, 500, 250, 0, 4420, 4422, 1, 0, 0, 0, 4421, 4403, 1, 0, 0, 0, 4421,
		4412, 1, 0, 0, 0, 4422, 499, 1, 0, 0, 0, 4423, 4428, 3, 502, 251, 0, 4424,
		4425, 5, 6, 0, 0, 4425, 4427, 3, 502, 251, 0, 4426, 4424, 1, 0, 0, 0, 4427,
		4430, 1, 0, 0, 0, 4428, 4426, 1, 0, 0, 0, 4428, 4429, 1, 0, 0, 0, 4429,
		501, 1, 0, 0, 0, 4430, 4428, 1, 0, 0, 0, 4431, 4432, 5, 271, 0, 0, 4432,
		4433, 3, 1356, 678, 0, 4433, 4434, 5, 2, 0, 0, 4434, 4435, 3, 1286, 643,
		0, 4435, 4436, 5, 3, 0, 0, 4436, 4444, 1, 0, 0, 0, 4437, 4438, 5, 211,
		0, 0, 4438, 4439, 3, 1356, 678, 0, 4439, 4440, 5, 2, 0, 0, 4440, 4441,
		3, 1286, 643, 0, 4441, 4442, 5, 3, 0, 0, 4442, 4444, 1, 0, 0, 0, 4443,
		4431, 1, 0, 0, 0, 4443, 4437, 1, 0, 0, 0, 4444, 503, 1, 0, 0, 0, 4445,
		4446, 5, 191, 0, 0, 4446, 4447, 5, 271, 0, 0, 4447, 4448, 5, 156, 0, 0,
		4448, 4449, 3, 524, 262, 0, 4449, 4450, 5, 100, 0, 0, 4450, 4451, 3, 1340,
		670, 0, 4451, 4452, 3, 108, 54, 0, 4452, 4464, 1, 0, 0, 0, 4453, 4454,
		5, 191, 0, 0, 4454, 4455, 5, 271, 0, 0, 4455, 4456, 5, 156, 0, 0, 4456,
		4457, 5, 220, 0, 0, 4457, 4458, 5, 389, 0, 0, 4458, 4459, 3, 524, 262,
		0, 4459, 4460, 5, 100, 0, 0, 4460, 4461, 3, 1340, 670, 0, 4461, 4462, 3,
		108, 54, 0, 4462, 4464, 1, 0, 0, 0, 4463, 4445, 1, 0, 0, 0, 4463, 4453,
		1, 0, 0, 0, 4464, 505, 1, 0, 0, 0, 4465, 4466, 5, 191, 0, 0, 4466, 4467,
		5, 271, 0, 0, 4467, 4468, 5, 206, 0, 0, 4468, 4469, 3, 524, 262, 0, 4469,
		4470, 5, 100, 0, 0, 4470, 4471, 3, 1340, 670, 0, 4471, 4472, 3, 108, 54,
		0, 4472, 4484, 1, 0, 0, 0, 4473, 4474, 5, 191, 0, 0, 4474, 4475, 5, 271,
		0, 0, 4475, 4476, 5, 206, 0, 0, 4476, 4477, 5, 220, 0, 0, 4477, 4478, 5,
		389, 0, 0, 4478, 4479, 3, 524, 262, 0, 4479, 4480, 5, 100, 0, 0, 4480,
		4481, 3, 1340, 670, 0, 4481, 4482, 3, 108, 54, 0, 4482, 4484, 1, 0, 0,
		0, 4483, 4465, 1, 0, 0, 0, 4483, 4473, 1, 0, 0, 0, 4484, 507, 1, 0, 0,
		0, 4485, 4486, 5, 191, 0, 0, 4486, 4487, 5, 274, 0, 0, 4487, 4488, 5, 147,
		0, 0, 4488, 4489, 3, 1370, 685, 0, 4489, 4490, 3, 108, 54, 0, 4490, 509,
		1, 0, 0, 0, 4491, 4492, 5, 294, 0, 0, 4492, 4493, 5, 274, 0, 0, 4493, 4494,
		5, 147, 0, 0, 4494, 4495, 3, 1370, 685, 0, 4495, 4496, 5, 94, 0, 0, 4496,
		4497, 3, 1368, 684, 0, 4497, 511, 1, 0, 0, 0, 4498, 4499, 5, 191, 0, 0,
		4499, 4500, 3, 514, 257, 0, 4500, 4501, 5, 220, 0, 0, 4501, 4502, 5, 389,
		0, 0, 4502, 4503, 3, 522, 261, 0, 4503, 4504, 3, 108, 54, 0, 4504, 4577,
		1, 0, 0, 0, 4505, 4506, 5, 191, 0, 0, 4506, 4507, 3, 514, 257, 0, 4507,
		4508, 3, 522, 261, 0, 4508, 4509, 3, 108, 54, 0, 4509, 4577, 1, 0, 0, 0,
		4510, 4511, 5, 191, 0, 0, 4511, 4512, 3, 518, 259, 0, 4512, 4513, 5, 220,
		0, 0, 4513, 4514, 5, 389, 0, 0, 4514, 4515, 3, 1338, 669, 0, 4515, 4516,
		3, 108, 54, 0, 4516, 4577, 1, 0, 0, 0, 4517, 4518, 5, 191, 0, 0, 4518,
		4519, 3, 518, 259, 0, 4519, 4520, 3, 1338, 669, 0, 4520, 4521, 3, 108,
		54, 0, 4521, 4577, 1, 0, 0, 0, 4522, 4523, 5, 191, 0, 0, 4523, 4524, 3,
		520, 260, 0, 4524, 4525, 3, 1340, 670, 0, 4525, 4526, 5, 80, 0, 0, 4526,
		4527, 3, 524, 262, 0, 4527, 4528, 3, 108, 54, 0, 4528, 4577, 1, 0, 0, 0,
		4529, 4530, 5, 191, 0, 0, 4530, 4531, 3, 520, 260, 0, 4531, 4532, 5, 220,
		0, 0, 4532, 4533, 5, 389, 0, 0, 4533, 4534, 3, 1340, 670, 0, 4534, 4535,
		5, 80, 0, 0, 4535, 4536, 3, 524, 262, 0, 4536, 4537, 3, 108, 54, 0, 4537,
		4577, 1, 0, 0, 0, 4538, 4539, 5, 191, 0, 0, 4539, 4540, 5, 353, 0, 0, 4540,
		4541, 3, 528, 264, 0, 4541, 4542, 3, 108, 54, 0, 4542, 4577, 1, 0, 0, 0,
		4543, 4544, 5, 191, 0, 0, 4544, 4545, 5, 353, 0, 0, 4545, 4546, 5, 220,
		0, 0, 4546, 4547, 5, 389, 0, 0, 4547, 4548, 3, 528, 264, 0, 4548, 4549,
		3, 108, 54, 0, 4549, 4577, 1, 0, 0, 0, 4550, 4551, 5, 191, 0, 0, 4551,
		4552, 5, 189, 0, 0, 4552, 4553, 3, 528, 264, 0, 4553, 4554, 3, 108, 54,
		0, 4554, 4577, 1, 0, 0, 0, 4555, 4556, 5, 191, 0, 0, 4556, 4557, 5, 189,
		0, 0, 4557, 4558, 5, 220, 0, 0, 4558, 4559, 5, 389, 0, 0, 4559, 4560, 3,
		528, 264, 0, 4560, 4561, 3, 108, 54, 0, 4561, 4577, 1, 0, 0, 0, 4562, 4563,
		5, 191, 0, 0, 4563, 4564, 5, 226, 0, 0, 4564, 4565, 5, 109, 0, 0, 4565,
		4566, 3, 522, 261, 0, 4566, 4567, 3, 108, 54, 0, 4567, 4577, 1, 0, 0, 0,
		4568, 4569, 5, 191, 0, 0, 4569, 4570, 5, 226, 0, 0, 4570, 4571, 5, 109,
		0, 0, 4571, 4572, 5, 220, 0, 0, 4572, 4573, 5, 389, 0, 0, 4573, 4574, 3,
		522, 261, 0, 4574, 4575, 3, 108, 54, 0, 4575, 4577, 1, 0, 0, 0, 4576, 4498,
		1, 0, 0, 0, 4576, 4505, 1, 0, 0, 0, 4576, 4510, 1, 0, 0, 0, 4576, 4517,
		1, 0, 0, 0, 4576, 4522, 1, 0, 0, 0, 4576, 4529, 1, 0, 0, 0, 4576, 4538,
		1, 0, 0, 0, 4576, 4543, 1, 0, 0, 0, 4576, 4550, 1, 0, 0, 0, 4576, 4555,
		1, 0, 0, 0, 4576, 4562, 1, 0, 0, 0, 4576, 4568, 1, 0, 0, 0, 4577, 513,
		1, 0, 0, 0, 4578, 4602, 5, 92, 0, 0, 4579, 4602, 5, 321, 0, 0, 4580, 4602,
		5, 369, 0, 0, 4581, 4582, 5, 251, 0, 0, 4582, 4602, 5, 369, 0, 0, 4583,
		4602, 5, 226, 0, 0, 4584, 4585, 5, 63, 0, 0, 4585, 4602, 5, 92, 0, 0, 4586,
		4602, 5, 108, 0, 0, 4587, 4602, 5, 168, 0, 0, 4588, 4602, 5, 335, 0, 0,
		4589, 4590, 5, 348, 0, 0, 4590, 4591, 5, 318, 0, 0, 4591, 4602, 5, 276,
		0, 0, 4592, 4593, 5, 348, 0, 0, 4593, 4594, 5, 318, 0, 0, 4594, 4602, 5,
		185, 0, 0, 4595, 4596, 5, 348, 0, 0, 4596, 4597, 5, 318, 0, 0, 4597, 4602,
		5, 346, 0, 0, 4598, 4599, 5, 348, 0, 0, 4599, 4600, 5, 318, 0, 0, 4600,
		4602, 5, 163, 0, 0, 4601, 4578, 1, 0, 0, 0, 4601, 4579, 1, 0, 0, 0, 4601,
		4580, 1, 0, 0, 0, 4601, 4581, 1, 0, 0, 0, 4601, 4583, 1, 0, 0, 0, 4601,
		4584, 1, 0, 0, 0, 4601, 4586, 1, 0, 0, 0, 4601, 4587, 1, 0, 0, 0, 4601,
		4588, 1, 0, 0, 0, 4601, 4589, 1, 0, 0, 0, 4601, 4592, 1, 0, 0, 0, 4601,
		4595, 1, 0, 0, 0, 4601, 4598, 1, 0, 0, 0, 4602, 515, 1, 0, 0, 0, 4603,
		4609, 3, 518, 259, 0, 4604, 4609, 5, 175, 0, 0, 4605, 4609, 5, 311, 0,
		0, 4606, 4609, 5, 451, 0, 0, 4607, 4609, 5, 344, 0, 0, 4608, 4603, 1, 0,
		0, 0, 4608, 4604, 1, 0, 0, 0, 4608, 4605, 1, 0, 0, 0, 4608, 4606, 1, 0,
		0, 0, 4608, 4607, 1, 0, 0, 0, 4609, 517, 1, 0, 0, 0, 4610, 4611, 5, 131,
		0, 0, 4611, 4625, 5, 446, 0, 0, 4612, 4613, 5, 198, 0, 0, 4613, 4625, 5,
		350, 0, 0, 4614, 4625, 5, 204, 0, 0, 4615, 4616, 5, 63, 0, 0, 4616, 4617,
		5, 174, 0, 0, 4617, 4625, 5, 374, 0, 0, 4618, 4619, 3, 308, 154, 0, 4619,
		4620, 5, 238, 0, 0, 4620, 4625, 1, 0, 0, 0, 4621, 4625, 5, 452, 0, 0, 4622,
		4625, 5, 316, 0, 0, 4623, 4625, 5, 324, 0, 0, 4624, 4610, 1, 0, 0, 0, 4624,
		4612, 1, 0, 0, 0, 4624, 4614, 1, 0, 0, 0, 4624, 4615, 1, 0, 0, 0, 4624,
		4618, 1, 0, 0, 0, 4624, 4621, 1, 0, 0, 0, 4624, 4622, 1, 0, 0, 0, 4624,
		4623, 1, 0, 0, 0, 4625, 519, 1, 0, 0, 0, 4626, 4627, 7, 23, 0, 0, 4627,
		521, 1, 0, 0, 0, 4628, 4633, 3, 524, 262, 0, 4629, 4630, 5, 6, 0, 0, 4630,
		4632, 3, 524, 262, 0, 4631, 4629, 1, 0, 0, 0, 4632, 4635, 1, 0, 0, 0, 4633,
		4631, 1, 0, 0, 0, 4633, 4634, 1, 0, 0, 0, 4634, 523, 1, 0, 0, 0, 4635,
		4633, 1, 0, 0, 0, 4636, 4638, 3, 1372, 686, 0, 4637, 4639, 3, 526, 263,
		0, 4638, 4637, 1, 0, 0, 0, 4638, 4639, 1, 0, 0, 0, 4639, 525, 1, 0, 0,
		0, 4640, 4641, 5, 11, 0, 0, 4641, 4643, 3, 1342, 671, 0, 4642, 4640, 1,
		0, 0, 0, 4643, 4644, 1, 0, 0, 0, 4644, 4642, 1, 0, 0, 0, 4644, 4645, 1,
		0, 0, 0, 4645, 527, 1, 0, 0, 0, 4646, 4651, 3, 1118, 559, 0, 4647, 4648,
		5, 6, 0, 0, 4648, 4650, 3, 1118, 559, 0, 4649, 4647, 1, 0, 0, 0, 4650,
		4653, 1, 0, 0, 0, 4651, 4649, 1, 0, 0, 0, 4651, 4652, 1, 0, 0, 0, 4652,
		529, 1, 0, 0, 0, 4653, 4651, 1, 0, 0, 0, 4654, 4655, 5, 351, 0, 0, 4655,
		4656, 3, 988, 494, 0, 4656, 4657, 3, 1076, 538, 0, 4657, 4658, 3, 532,
		266, 0, 4658, 4659, 3, 108, 54, 0, 4659, 531, 1, 0, 0, 0, 4660, 4661, 5,
		167, 0, 0, 4661, 4666, 5, 219, 0, 0, 4662, 4663, 5, 307, 0, 0, 4663, 4666,
		5, 219, 0, 0, 4664, 4666, 1, 0, 0, 0, 4665, 4660, 1, 0, 0, 0, 4665, 4662,
		1, 0, 0, 0, 4665, 4664, 1, 0, 0, 0, 4666, 533, 1, 0, 0, 0, 4667, 4668,
		5, 159, 0, 0, 4668, 4669, 5, 80, 0, 0, 4669, 4670, 3, 514, 257, 0, 4670,
		4671, 3, 524, 262, 0, 4671, 4672, 5, 116, 0, 0, 4672, 4673, 3, 536, 268,
		0, 4673, 4815, 1, 0, 0, 0, 4674, 4675, 5, 159, 0, 0, 4675, 4676, 5, 80,
		0, 0, 4676, 4677, 5, 44, 0, 0, 4677, 4678, 3, 524, 262, 0, 4678, 4679,
		5, 116, 0, 0, 4679, 4680, 3, 536, 268, 0, 4680, 4815, 1, 0, 0, 0, 4681,
		4682, 5, 159, 0, 0, 4682, 4683, 5, 80, 0, 0, 4683, 4684, 3, 516, 258, 0,
		4684, 4685, 3, 1340, 670, 0, 4685, 4686, 5, 116, 0, 0, 4686, 4687, 3, 536,
		268, 0, 4687, 4815, 1, 0, 0, 0, 4688, 4689, 5, 159, 0, 0, 4689, 4690, 5,
		80, 0, 0, 4690, 4691, 5, 353, 0, 0, 4691, 4692, 3, 1118, 559, 0, 4692,
		4693, 5, 116, 0, 0, 4693, 4694, 3, 536, 268, 0, 4694, 4815, 1, 0, 0, 0,
		4695, 4696, 5, 159, 0, 0, 4696, 4697, 5, 80, 0, 0, 4697, 4698, 5, 189,
		0, 0, 4698, 4699, 3, 1118, 559, 0, 4699, 4700, 5, 116, 0, 0, 4700, 4701,
		3, 536, 268, 0, 4701, 4815, 1, 0, 0, 0, 4702, 4703, 5, 159, 0, 0, 4703,
		4704, 5, 80, 0, 0, 4704, 4705, 5, 136, 0, 0, 4705, 4706, 3, 650, 325, 0,
		4706, 4707, 5, 116, 0, 0, 4707, 4708, 3, 536, 268, 0, 4708, 4815, 1, 0,
		0, 0, 4709, 4710, 5, 159, 0, 0, 4710, 4711, 5, 80, 0, 0, 4711, 4712, 5,
		211, 0, 0, 4712, 4713, 3, 626, 313, 0, 4713, 4714, 5, 116, 0, 0, 4714,
		4715, 3, 536, 268, 0, 4715, 4815, 1, 0, 0, 0, 4716, 4717, 5, 159, 0, 0,
		4717, 4718, 5, 80, 0, 0, 4718, 4719, 5, 271, 0, 0, 4719, 4720, 3, 688,
		344, 0, 4720, 4721, 5, 116, 0, 0, 4721, 4722, 3, 536, 268, 0, 4722, 4815,
		1, 0, 0, 0, 4723, 4724, 5, 159, 0, 0, 4724, 4725, 5, 80, 0, 0, 4725, 4726,
		5, 45, 0, 0, 4726, 4727, 3, 1340, 670, 0, 4727, 4728, 5, 80, 0, 0, 4728,
		4729, 3, 524, 262, 0, 4729, 4730, 5, 116, 0, 0, 4730, 4731, 3, 536, 268,
		0, 4731, 4815, 1, 0, 0, 0, 4732, 4733, 5, 159, 0, 0, 4733, 4734, 5, 80,
		0, 0, 4734, 4735, 5, 45, 0, 0, 4735, 4736, 3, 1340, 670, 0, 4736, 4737,
		5, 80, 0, 0, 4737, 4738, 5, 189, 0, 0, 4738, 4739, 3, 524, 262, 0, 4739,
		4740, 5, 116, 0, 0, 4740, 4741, 3, 536, 268, 0, 4741, 4815, 1, 0, 0, 0,
		4742, 4743, 5, 159, 0, 0, 4743, 4744, 5, 80, 0, 0, 4744, 4745, 3, 520,
		260, 0, 4745, 4746, 3, 1340, 670, 0, 4746, 4747, 5, 80, 0, 0, 4747, 4748,
		3, 524, 262, 0, 4748, 4749, 5, 116, 0, 0, 4749, 4750, 3, 536, 268, 0, 4750,
		4815, 1, 0, 0, 0, 4751, 4752, 5, 159, 0, 0, 4752, 4753, 5, 80, 0, 0, 4753,
		4754, 5, 289, 0, 0, 4754, 4755, 3, 626, 313, 0, 4755, 4756, 5, 116, 0,
		0, 4756, 4757, 3, 536, 268, 0, 4757, 4815, 1, 0, 0, 0, 4758, 4759, 5, 159,
		0, 0, 4759, 4760, 5, 80, 0, 0, 4760, 4761, 5, 442, 0, 0, 4761, 4762, 3,
		626, 313, 0, 4762, 4763, 5, 116, 0, 0, 4763, 4764, 3, 536, 268, 0, 4764,
		4815, 1, 0, 0, 0, 4765, 4766, 5, 159, 0, 0, 4766, 4767, 5, 80, 0, 0, 4767,
		4768, 5, 443, 0, 0, 4768, 4769, 5, 62, 0, 0, 4769, 4770, 3, 1118, 559,
		0, 4770, 4771, 5, 238, 0, 0, 4771, 4772, 3, 1340, 670, 0, 4772, 4773, 5,
		116, 0, 0, 4773, 4774, 3, 536, 268, 0, 4774, 4815, 1, 0, 0, 0, 4775, 4776,
		5, 159, 0, 0, 4776, 4777, 5, 80, 0, 0, 4777, 4778, 5, 271, 0, 0, 4778,
		4779, 5, 156, 0, 0, 4779, 4780, 3, 524, 262, 0, 4780, 4781, 5, 100, 0,
		0, 4781, 4782, 3, 1340, 670, 0, 4782, 4783, 5, 116, 0, 0, 4783, 4784, 3,
		536, 268, 0, 4784, 4815, 1, 0, 0, 0, 4785, 4786, 5, 159, 0, 0, 4786, 4787,
		5, 80, 0, 0, 4787, 4788, 5, 271, 0, 0, 4788, 4789, 5, 206, 0, 0, 4789,
		4790, 3, 524, 262, 0, 4790, 4791, 5, 100, 0, 0, 4791, 4792, 3, 1340, 670,
		0, 4792, 4793, 5, 116, 0, 0, 4793, 4794, 3, 536, 268, 0, 4794, 4815, 1,
		0, 0, 0, 4795, 4796, 5, 159, 0, 0, 4796, 4797, 5, 80, 0, 0, 4797, 4798,
		5, 239, 0, 0, 4798, 4799, 5, 267, 0, 0, 4799, 4800, 3, 292, 146, 0, 4800,
		4801, 5, 116, 0, 0, 4801, 4802, 3, 536, 268, 0, 4802, 4815, 1, 0, 0, 0,
		4803, 4804, 5, 159, 0, 0, 4804, 4805, 5, 80, 0, 0, 4805, 4806, 5, 41, 0,
		0, 4806, 4807, 5, 2, 0, 0, 4807, 4808, 3, 1118, 559, 0, 4808, 4809, 5,
		36, 0, 0, 4809, 4810, 3, 1118, 559, 0, 4810, 4811, 5, 3, 0, 0, 4811, 4812,
		5, 116, 0, 0, 4812, 4813, 3, 536, 268, 0, 4813, 4815, 1, 0, 0, 0, 4814,
		4667, 1, 0, 0, 0, 4814, 4674, 1, 0, 0, 0, 4814, 4681, 1, 0, 0, 0, 4814,
		4688, 1, 0, 0, 0, 4814, 4695, 1, 0, 0, 0, 4814, 4702, 1, 0, 0, 0, 4814,
		4709, 1, 0, 0, 0, 4814, 4716, 1, 0, 0, 0, 4814, 4723, 1, 0, 0, 0, 4814,
		4732, 1, 0, 0, 0, 4814, 4742, 1, 0, 0, 0, 4814, 4751, 1, 0, 0, 0, 4814,
		4758, 1, 0, 0, 0, 4814, 4765, 1, 0, 0, 0, 4814, 4775, 1, 0, 0, 0, 4814,
		4785, 1, 0, 0, 0, 4814, 4795, 1, 0, 0, 0, 4814, 4803, 1, 0, 0, 0, 4815,
		535, 1, 0, 0, 0, 4816, 4819, 3, 1358, 679, 0, 4817, 4819, 5, 78, 0, 0,
		4818, 4816, 1, 0, 0, 0, 4818, 4817, 1, 0, 0, 0, 4819, 537, 1, 0, 0, 0,
		4820, 4821, 5, 320, 0, 0, 4821, 4822, 5, 237, 0, 0, 4822, 4823, 3, 540,
		270, 0, 4823, 4824, 5, 80, 0, 0, 4824, 4825, 3, 514, 257, 0, 4825, 4826,
		3, 524, 262, 0, 4826, 4827, 5, 116, 0, 0, 4827, 4828, 3, 542, 271, 0, 4828,
		4912, 1, 0, 0, 0, 4829, 4830, 5, 320, 0, 0, 4830, 4831, 5, 237, 0, 0, 4831,
		4832, 3, 540, 270, 0, 4832, 4833, 5, 80, 0, 0, 4833, 4834, 5, 44, 0, 0,
		4834, 4835, 3, 524, 262, 0, 4835, 4836, 5, 116, 0, 0, 4836, 4837, 3, 542,
		271, 0, 4837, 4912, 1, 0, 0, 0, 4838, 4839, 5, 320, 0, 0, 4839, 4840, 5,
		237, 0, 0, 4840, 4841, 3, 540, 270, 0, 4841, 4842, 5, 80, 0, 0, 4842, 4843,
		3, 516, 258, 0, 4843, 4844, 3, 1340, 670, 0, 4844, 4845, 5, 116, 0, 0,
		4845, 4846, 3, 542, 271, 0, 4846, 4912, 1, 0, 0, 0, 4847, 4848, 5, 320,
		0, 0, 4848, 4849, 5, 237, 0, 0, 4849, 4850, 3, 540, 270, 0, 4850, 4851,
		5, 80, 0, 0, 4851, 4852, 5, 353, 0, 0, 4852, 4853, 3, 1118, 559, 0, 4853,
		4854, 5, 116, 0, 0, 4854, 4855, 3, 542, 271, 0, 4855, 4912, 1, 0, 0, 0,
		4856, 4857, 5, 320, 0, 0, 4857, 4858, 5, 237, 0, 0, 4858, 4859, 3, 540,
		270, 0, 4859, 4860, 5, 80, 0, 0, 4860, 4861, 5, 189, 0, 0, 4861, 4862,
		3, 1118, 559, 0, 4862, 4863, 5, 116, 0, 0, 4863, 4864, 3, 542, 271, 0,
		4864, 4912, 1, 0, 0, 0, 4865, 4866, 5, 320, 0, 0, 4866, 4867, 5, 237, 0,
		0, 4867, 4868, 3, 540, 270, 0, 4868, 4869, 5, 80, 0, 0, 4869, 4870, 5,
		136, 0, 0, 4870, 4871, 3, 650, 325, 0, 4871, 4872, 5, 116, 0, 0, 4872,
		4873, 3, 542, 271, 0, 4873, 4912, 1, 0, 0, 0, 4874, 4875, 5, 320, 0, 0,
		4875, 4876, 5, 237, 0, 0, 4876, 4877, 3, 540, 270, 0, 4877, 4878, 5, 80,
		0, 0, 4878, 4879, 5, 211, 0, 0, 4879, 4880, 3, 626, 313, 0, 4880, 4881,
		5, 116, 0, 0, 4881, 4882, 3, 542, 271, 0, 4882, 4912, 1, 0, 0, 0, 4883,
		4884, 5, 320, 0, 0, 4884, 4885, 5, 237, 0, 0, 4885, 4886, 3, 540, 270,
		0, 4886, 4887, 5, 80, 0, 0, 4887, 4888, 5, 239, 0, 0, 4888, 4889, 5, 267,
		0, 0, 4889, 4890, 3, 292, 146, 0, 4890, 4891, 5, 116, 0, 0, 4891, 4892,
		3, 542, 271, 0, 4892, 4912, 1, 0, 0, 0, 4893, 4894, 5, 320, 0, 0, 4894,
		4895, 5, 237, 0, 0, 4895, 4896, 3, 540, 270, 0, 4896, 4897, 5, 80, 0, 0,
		4897, 4898, 5, 289, 0, 0, 4898, 4899, 3, 626, 313, 0, 4899, 4900, 5, 116,
		0, 0, 4900, 4901, 3, 542, 271, 0, 4901, 4912, 1, 0, 0, 0, 4902, 4903, 5,
		320, 0, 0, 4903, 4904, 5, 237, 0, 0, 4904, 4905, 3, 540, 270, 0, 4905,
		4906, 5, 80, 0, 0, 4906, 4907, 5, 442, 0, 0, 4907, 4908, 3, 626, 313, 0,
		4908, 4909, 5, 116, 0, 0, 4909, 4910, 3, 542, 271, 0, 4910, 4912, 1, 0,
		0, 0, 4911, 4820, 1, 0, 0, 0, 4911, 4829, 1, 0, 0, 0, 4911, 4838, 1, 0,
		0, 0, 4911, 4847, 1, 0, 0, 0, 4911, 4856, 1, 0, 0, 0, 4911, 4865, 1, 0,
		0, 0, 4911, 4874, 1, 0, 0, 0, 4911, 4883, 1, 0, 0, 0, 4911, 4893, 1, 0,
		0, 0, 4911, 4902, 1, 0, 0, 0, 4912, 539, 1, 0, 0, 0, 4913, 4914, 5, 62,
		0, 0, 4914, 4917, 3, 72, 36, 0, 4915, 4917, 1, 0, 0, 0, 4916, 4913, 1,
		0, 0, 0, 4916, 4915, 1, 0, 0, 0, 4917, 541, 1, 0, 0, 0, 4918, 4921, 3,
		1358, 679, 0, 4919, 4921, 5, 78, 0, 0, 4920, 4918, 1, 0, 0, 0, 4920, 4919,
		1, 0, 0, 0, 4921, 543, 1, 0, 0, 0, 4922, 4923, 5, 61, 0, 0, 4923, 4927,
		3, 546, 273, 0, 4924, 4925, 5, 258, 0, 0, 4925, 4927, 3, 546, 273, 0, 4926,
		4922, 1, 0, 0, 0, 4926, 4924, 1, 0, 0, 0, 4927, 545, 1, 0, 0, 0, 4928,
		4995, 3, 954, 477, 0, 4929, 4930, 3, 548, 274, 0, 4930, 4931, 3, 954, 477,
		0, 4931, 4995, 1, 0, 0, 0, 4932, 4933, 5, 261, 0, 0, 4933, 4934, 3, 550,
		275, 0, 4934, 4935, 3, 954, 477, 0, 4935, 4995, 1, 0, 0, 0, 4936, 4937,
		5, 286, 0, 0, 4937, 4938, 3, 550, 275, 0, 4938, 4939, 3, 954, 477, 0, 4939,
		4995, 1, 0, 0, 0, 4940, 4941, 5, 207, 0, 0, 4941, 4942, 3, 550, 275, 0,
		4942, 4943, 3, 954, 477, 0, 4943, 4995, 1, 0, 0, 0, 4944, 4945, 5, 240,
		0, 0, 4945, 4946, 3, 550, 275, 0, 4946, 4947, 3, 954, 477, 0, 4947, 4995,
		1, 0, 0, 0, 4948, 4949, 5, 130, 0, 0, 4949, 4950, 3, 1364, 682, 0, 4950,
		4951, 3, 550, 275, 0, 4951, 4952, 3, 954, 477, 0, 4952, 4995, 1, 0, 0,
		0, 4953, 4954, 5, 300, 0, 0, 4954, 4955, 3, 1364, 682, 0, 4955, 4956, 3,
		550, 275, 0, 4956, 4957, 3, 954, 477, 0, 4957, 4995, 1, 0, 0, 0, 4958,
		4959, 3, 1364, 682, 0, 4959, 4960, 3, 550, 275, 0, 4960, 4961, 3, 954,
		477, 0, 4961, 4995, 1, 0, 0, 0, 4962, 4963, 5, 30, 0, 0, 4963, 4964, 3,
		550, 275, 0, 4964, 4965, 3, 954, 477, 0, 4965, 4995, 1, 0, 0, 0, 4966,
		4967, 5, 210, 0, 0, 4967, 4968, 3, 550, 275, 0, 4968, 4969, 3, 954, 477,
		0, 4969, 4995, 1, 0, 0, 0, 4970, 4971, 5, 210, 0, 0, 4971, 4972, 3, 1364,
		682, 0, 4972, 4973, 3, 550, 275, 0, 4973, 4974, 3, 954, 477, 0, 4974, 4995,
		1, 0, 0, 0, 4975, 4976, 5, 210, 0, 0, 4976, 4977, 5, 30, 0, 0, 4977, 4978,
		3, 550, 275, 0, 4978, 4979, 3, 954, 477, 0, 4979, 4995, 1, 0, 0, 0, 4980,
		4981, 5, 144, 0, 0, 4981, 4982, 3, 550, 275, 0, 4982, 4983, 3, 954, 477,
		0, 4983, 4995, 1, 0, 0, 0, 4984, 4985, 5, 144, 0, 0, 4985, 4986, 3, 1364,
		682, 0, 4986, 4987, 3, 550, 275, 0, 4987, 4988, 3, 954, 477, 0, 4988, 4995,
		1, 0, 0, 0, 4989, 4990, 5, 144, 0, 0, 4990, 4991, 5, 30, 0, 0, 4991, 4992,
		3, 550, 275, 0, 4992, 4993, 3, 954, 477, 0, 4993, 4995, 1, 0, 0, 0, 4994,
		4928, 1, 0, 0, 0, 4994, 4929, 1, 0, 0, 0, 4994, 4932, 1, 0, 0, 0, 4994,
		4936, 1, 0, 0, 0, 4994, 4940, 1, 0, 0, 0, 4994, 4944, 1, 0, 0, 0, 4994,
		4948, 1, 0, 0, 0, 4994, 4953, 1, 0, 0, 0, 4994, 4958, 1, 0, 0, 0, 4994,
		4962, 1, 0, 0, 0, 4994, 4966, 1, 0, 0, 0, 4994, 4970, 1, 0, 0, 0, 4994,
		4975, 1, 0, 0, 0, 4994, 4980, 1, 0, 0, 0, 4994, 4984, 1, 0, 0, 0, 4994,
		4989, 1, 0, 0, 0, 4995, 547, 1, 0, 0, 0, 4996, 4997, 7, 24, 0, 0, 4997,
		549, 1, 0, 0, 0, 4998, 5001, 3, 548, 274, 0, 4999, 5001, 1, 0, 0, 0, 5000,
		4998, 1, 0, 0, 0, 5000, 4999, 1, 0, 0, 0, 5001, 551, 1, 0, 0, 0, 5002,
		5003, 5, 65, 0, 0, 5003, 5004, 3, 556, 278, 0, 5004, 5005, 5, 80, 0, 0,
		5005, 5006, 3, 562, 281, 0, 5006, 5007, 5, 94, 0, 0, 5007, 5008, 3, 564,
		282, 0, 5008, 5009, 3, 568, 284, 0, 5009, 553, 1, 0, 0, 0, 5010, 5011,
		5, 310, 0, 0, 5011, 5012, 3, 556, 278, 0, 5012, 5013, 5, 80, 0, 0, 5013,
		5014, 3, 562, 281, 0, 5014, 5015, 5, 64, 0, 0, 5015, 5016, 3, 564, 282,
		0, 5016, 5017, 3, 108, 54, 0, 5017, 5030, 1, 0, 0, 0, 5018, 5019, 5, 310,
		0, 0, 5019, 5020, 5, 65, 0, 0, 5020, 5021, 5, 272, 0, 0, 5021, 5022, 5,
		62, 0, 0, 5022, 5023, 3, 556, 278, 0, 5023, 5024, 5, 80, 0, 0, 5024, 5025,
		3, 562, 281, 0, 5025, 5026, 5, 64, 0, 0, 5026, 5027, 3, 564, 282, 0, 5027,
		5028, 3, 108, 54, 0, 5028, 5030, 1, 0, 0, 0, 5029, 5010, 1, 0, 0, 0, 5029,
		5018, 1, 0, 0, 0, 5030, 555, 1, 0, 0, 0, 5031, 5047, 3, 558, 279, 0, 5032,
		5047, 5, 30, 0, 0, 5033, 5034, 5, 30, 0, 0, 5034, 5047, 5, 287, 0, 0, 5035,
		5036, 5, 30, 0, 0, 5036, 5037, 5, 2, 0, 0, 5037, 5038, 3, 216, 108, 0,
		5038, 5039, 5, 3, 0, 0, 5039, 5047, 1, 0, 0, 0, 5040, 5041, 5, 30, 0, 0,
		5041, 5042, 5, 287, 0, 0, 5042, 5043, 5, 2, 0, 0, 5043, 5044, 3, 216, 108,
		0, 5044, 5045, 5, 3, 0, 0, 5045, 5047, 1, 0, 0, 0, 5046, 5031, 1, 0, 0,
		0, 5046, 5032, 1, 0, 0, 0, 5046, 5033, 1, 0, 0, 0, 5046, 5035, 1, 0, 0,
		0, 5046, 5040, 1, 0, 0, 0, 5047, 557, 1, 0, 0, 0, 5048, 5053, 3, 560, 280,
		0, 5049, 5050, 5, 6, 0, 0, 5050, 5052, 3, 560, 280, 0, 5051, 5049, 1, 0,
		0, 0, 5052, 5055, 1, 0, 0, 0, 5053, 5051, 1, 0, 0, 0, 5053, 5054, 1, 0,
		0, 0, 5054, 559, 1, 0, 0, 0, 5055, 5053, 1, 0, 0, 0, 5056, 5057, 5, 88,
		0, 0, 5057, 5066, 3, 214, 107, 0, 5058, 5059, 5, 86, 0, 0, 5059, 5066,
		3, 214, 107, 0, 5060, 5061, 5, 46, 0, 0, 5061, 5066, 3, 214, 107, 0, 5062,
		5063, 3, 1372, 686, 0, 5063, 5064, 3, 214, 107, 0, 5064, 5066, 1, 0, 0,
		0, 5065, 5056, 1, 0, 0, 0, 5065, 5058, 1, 0, 0, 0, 5065, 5060, 1, 0, 0,
		0, 5065, 5062, 1, 0, 0, 0, 5066, 561, 1, 0, 0, 0, 5067, 5126, 3, 1334,
		667, 0, 5068, 5069, 5, 92, 0, 0, 5069, 5126, 3, 1334, 667, 0, 5070, 5071,
		5, 321, 0, 0, 5071, 5126, 3, 1334, 667, 0, 5072, 5073, 5, 63, 0, 0, 5073,
		5074, 5, 174, 0, 0, 5074, 5075, 5, 374, 0, 0, 5075, 5126, 3, 1338, 669,
		0, 5076, 5077, 5, 63, 0, 0, 5077, 5078, 5, 324, 0, 0, 5078, 5126, 3, 1338,
		669, 0, 5079, 5080, 5, 211, 0, 0, 5080, 5126, 3, 624, 312, 0, 5081, 5082,
		5, 289, 0, 0, 5082, 5126, 3, 624, 312, 0, 5083, 5084, 5, 442, 0, 0, 5084,
		5126, 3, 624, 312, 0, 5085, 5086, 5, 175, 0, 0, 5086, 5126, 3, 1338, 669,
		0, 5087, 5088, 5, 189, 0, 0, 5088, 5126, 3, 522, 261, 0, 5089, 5090, 5,
		238, 0, 0, 5090, 5126, 3, 1338, 669, 0, 5091, 5092, 5, 239, 0, 0, 5092,
		5093, 5, 267, 0, 0, 5093, 5126, 3, 294, 147, 0, 5094, 5095, 5, 316, 0,
		0, 5095, 5126, 3, 1338, 669, 0, 5096, 5097, 5, 344, 0, 0, 5097, 5126, 3,
		1338, 669, 0, 5098, 5099, 5, 353, 0, 0, 5099, 5126, 3, 522, 261, 0, 5100,
		5101, 5, 30, 0, 0, 5101, 5102, 5, 343, 0, 0, 5102, 5103, 5, 68, 0, 0, 5103,
		5104, 5, 316, 0, 0, 5104, 5126, 3, 1338, 669, 0, 5105, 5106, 5, 30, 0,
		0, 5106, 5107, 5, 322, 0, 0, 5107, 5108, 5, 68, 0, 0, 5108, 5109, 5, 316,
		0, 0, 5109, 5126, 3, 1338, 669, 0, 5110, 5111, 5, 30, 0, 0, 5111, 5112,
		5, 212, 0, 0, 5112, 5113, 5, 68, 0, 0, 5113, 5114, 5, 316, 0, 0, 5114,
		5126, 3, 1338, 669, 0, 5115, 5116, 5, 30, 0, 0, 5116, 5117, 5, 457, 0,
		0, 5117, 5118, 5, 68, 0, 0, 5118, 5119, 5, 316, 0, 0, 5119, 5126, 3, 1338,
		669, 0, 5120, 5121, 5, 30, 0, 0, 5121, 5122, 5, 455, 0, 0, 5122, 5123,
		5, 68, 0, 0, 5123, 5124, 5, 316, 0, 0, 5124, 5126, 3, 1338, 669, 0, 5125,
		5067, 1, 0, 0, 0, 5125, 5068, 1, 0, 0, 0, 5125, 5070, 1, 0, 0, 0, 5125,
		5072, 1, 0, 0, 0, 5125, 5076, 1, 0, 0, 0, 5125, 5079, 1, 0, 0, 0, 5125,
		5081, 1, 0, 0, 0, 5125, 5083, 1, 0, 0, 0, 5125, 5085, 1, 0, 0, 0, 5125,
		5087, 1, 0, 0, 0, 5125, 5089, 1, 0, 0, 0, 5125, 5091, 1, 0, 0, 0, 5125,
		5094, 1, 0, 0, 0, 5125, 5096, 1, 0, 0, 0, 5125, 5098, 1, 0, 0, 0, 5125,
		5100, 1, 0, 0, 0, 5125, 5105, 1, 0, 0, 0, 5125, 5110, 1, 0, 0, 0, 5125,
		5115, 1, 0, 0, 0, 5125, 5120, 1, 0, 0, 0, 5126, 563, 1, 0, 0, 0, 5127,
		5132, 3, 566, 283, 0, 5128, 5129, 5, 6, 0, 0, 5129, 5131, 3, 566, 283,
		0, 5130, 5128, 1, 0, 0, 0, 5131, 5134, 1, 0, 0, 0, 5132, 5130, 1, 0, 0,
		0, 5132, 5133, 1, 0, 0, 0, 5133, 565, 1, 0, 0, 0, 5134, 5132, 1, 0, 0,
		0, 5135, 5139, 3, 1368, 684, 0, 5136, 5137, 5, 66, 0, 0, 5137, 5139, 3,
		1368, 684, 0, 5138, 5135, 1, 0, 0, 0, 5138, 5136, 1, 0, 0, 0, 5139, 567,
		1, 0, 0, 0, 5140, 5141, 5, 105, 0, 0, 5141, 5142, 5, 65, 0, 0, 5142, 5145,
		5, 272, 0, 0, 5143, 5145, 1, 0, 0, 0, 5144, 5140, 1, 0, 0, 0, 5144, 5143,
		1, 0, 0, 0, 5145, 569, 1, 0, 0, 0, 5146, 5147, 5, 65, 0, 0, 5147, 5148,
		3, 558, 279, 0, 5148, 5149, 5, 94, 0, 0, 5149, 5150, 3, 1370, 685, 0, 5150,
		5151, 3, 574, 287, 0, 5151, 5152, 3, 576, 288, 0, 5152, 571, 1, 0, 0, 0,
		5153, 5154, 5, 310, 0, 0, 5154, 5155, 3, 558, 279, 0, 5155, 5156, 5, 64,
		0, 0, 5156, 5157, 3, 1370, 685, 0, 5157, 5158, 3, 576, 288, 0, 5158, 5159,
		3, 108, 54, 0, 5159, 5171, 1, 0, 0, 0, 5160, 5161, 5, 310, 0, 0, 5161,
		5162, 5, 134, 0, 0, 5162, 5163, 5, 272, 0, 0, 5163, 5164, 5, 62, 0, 0,
		5164, 5165, 3, 558, 279, 0, 5165, 5166, 5, 64, 0, 0, 5166, 5167, 3, 1370,
		685, 0, 5167, 5168, 3, 576, 288, 0, 5168, 5169, 3, 108, 54, 0, 5169, 5171,
		1, 0, 0, 0, 5170, 5153, 1, 0, 0, 0, 5170, 5160, 1, 0, 0, 0, 5171, 573,
		1, 0, 0, 0, 5172, 5173, 5, 105, 0, 0, 5173, 5174, 5, 134, 0, 0, 5174, 5177,
		5, 272, 0, 0, 5175, 5177, 1, 0, 0, 0, 5176, 5172, 1, 0, 0, 0, 5176, 5175,
		1, 0, 0, 0, 5177, 575, 1, 0, 0, 0, 5178, 5179, 5, 214, 0, 0, 5179, 5180,
		5, 147, 0, 0, 5180, 5183, 3, 1368, 684, 0, 5181, 5183, 1, 0, 0, 0, 5182,
		5178, 1, 0, 0, 0, 5182, 5181, 1, 0, 0, 0, 5183, 577, 1, 0, 0, 0, 5184,
		5185, 5, 138, 0, 0, 5185, 5186, 5, 53, 0, 0, 5186, 5187, 5, 287, 0, 0,
		5187, 5188, 3, 580, 290, 0, 5188, 5189, 3, 584, 292, 0, 5189, 579, 1, 0,
		0, 0, 5190, 5192, 3, 582, 291, 0, 5191, 5190, 1, 0, 0, 0, 5192, 5195, 1,
		0, 0, 0, 5193, 5191, 1, 0, 0, 0, 5193, 5194, 1, 0, 0, 0, 5194, 581, 1,
		0, 0, 0, 5195, 5193, 1, 0, 0, 0, 5196, 5197, 5, 68, 0, 0, 5197, 5198, 5,
		316, 0, 0, 5198, 5206, 3, 1338, 669, 0, 5199, 5200, 5, 62, 0, 0, 5200,
		5201, 5, 311, 0, 0, 5201, 5206, 3, 1370, 685, 0, 5202, 5203, 5, 62, 0,
		0, 5203, 5204, 5, 99, 0, 0, 5204, 5206, 3, 1370, 685, 0, 5205, 5196, 1,
		0, 0, 0, 5205, 5199, 1, 0, 0, 0, 5205, 5202, 1, 0, 0, 0, 5206, 583, 1,
		0, 0, 0, 5207, 5208, 5, 65, 0, 0, 5208, 5209, 3, 556, 278, 0, 5209, 5210,
		5, 80, 0, 0, 5210, 5211, 3, 586, 293, 0, 5211, 5212, 5, 94, 0, 0, 5212,
		5213, 3, 564, 282, 0, 5213, 5214, 3, 568, 284, 0, 5214, 5235, 1, 0, 0,
		0, 5215, 5216, 5, 310, 0, 0, 5216, 5217, 3, 556, 278, 0, 5217, 5218, 5,
		80, 0, 0, 5218, 5219, 3, 586, 293, 0, 5219, 5220, 5, 64, 0, 0, 5220, 5221,
		3, 564, 282, 0, 5221, 5222, 3, 108, 54, 0, 5222, 5235, 1, 0, 0, 0, 5223,
		5224, 5, 310, 0, 0, 5224, 5225, 5, 65, 0, 0, 5225, 5226, 5, 272, 0, 0,
		5226, 5227, 5, 62, 0, 0, 5227, 5228, 3, 556, 278, 0, 5228, 5229, 5, 80,
		0, 0, 5229, 5230, 3, 586, 293, 0, 5230, 5231, 5, 64, 0, 0, 5231, 5232,
		3, 564, 282, 0, 5232, 5233, 3, 108, 54, 0, 5233, 5235, 1, 0, 0, 0, 5234,
		5207, 1, 0, 0, 0, 5234, 5215, 1, 0, 0, 0, 5234, 5223, 1, 0, 0, 0, 5235,
		585, 1, 0, 0, 0, 5236, 5237, 7, 25, 0, 0, 5237, 587, 1, 0, 0, 0, 5238,
		5239, 5, 46, 0, 0, 5239, 5240, 3, 590, 295, 0, 5240, 5241, 5, 226, 0, 0,
		5241, 5242, 3, 592, 296, 0, 5242, 5243, 3, 594, 297, 0, 5243, 5244, 5,
		80, 0, 0, 5244, 5245, 3, 1074, 537, 0, 5245, 5246, 3, 596, 298, 0, 5246,
		5247, 5, 2, 0, 0, 5247, 5248, 3, 598, 299, 0, 5248, 5249, 5, 3, 0, 0, 5249,
		5250, 3, 604, 302, 0, 5250, 5251, 3, 118, 59, 0, 5251, 5252, 3, 254, 127,
		0, 5252, 5253, 3, 1094, 547, 0, 5253, 5274, 1, 0, 0, 0, 5254, 5255, 5,
		46, 0, 0, 5255, 5256, 3, 590, 295, 0, 5256, 5257, 5, 226, 0, 0, 5257, 5258,
		3, 592, 296, 0, 5258, 5259, 5, 220, 0, 0, 5259, 5260, 5, 77, 0, 0, 5260,
		5261, 5, 389, 0, 0, 5261, 5262, 3, 1340, 670, 0, 5262, 5263, 5, 80, 0,
		0, 5263, 5264, 3, 1074, 537, 0, 5264, 5265, 3, 596, 298, 0, 5265, 5266,
		5, 2, 0, 0, 5266, 5267, 3, 598, 299, 0, 5267, 5268, 5, 3, 0, 0, 5268, 5269,
		3, 604, 302, 0, 5269, 5270, 3, 118, 59, 0, 5270, 5271, 3, 254, 127, 0,
		5271, 5272, 3, 1094, 547, 0, 5272, 5274, 1, 0, 0, 0, 5273, 5238, 1, 0,
		0, 0, 5273, 5254, 1, 0, 0, 0, 5274, 589, 1, 0, 0, 0, 5275, 5278, 5, 98,
		0, 0, 5276, 5278, 1, 0, 0, 0, 5277, 5275, 1, 0, 0, 0, 5277, 5276, 1, 0,
		0, 0, 5278, 591, 1, 0, 0, 0, 5279, 5282, 5, 109, 0, 0, 5280, 5282, 1, 0,
		0, 0, 5281, 5279, 1, 0, 0, 0, 5281, 5280, 1, 0, 0, 0, 5282, 593, 1, 0,
		0, 0, 5283, 5286, 3, 1340, 670, 0, 5284, 5286, 1, 0, 0, 0, 5285, 5283,
		1, 0, 0, 0, 5285, 5284, 1, 0, 0, 0, 5286, 595, 1, 0, 0, 0, 5287, 5288,
		5, 100, 0, 0, 5288, 5291, 3, 1340, 670, 0, 5289, 5291, 1, 0, 0, 0, 5290,
		5287, 1, 0, 0, 0, 5290, 5289, 1, 0, 0, 0, 5291, 597, 1, 0, 0, 0, 5292,
		5297, 3, 602, 301, 0, 5293, 5294, 5, 6, 0, 0, 5294, 5296, 3, 602, 301,
		0, 5295, 5293, 1, 0, 0, 0, 5296, 5299, 1, 0, 0, 0, 5297, 5295, 1, 0, 0,
		0, 5297, 5298, 1, 0, 0, 0, 5298, 599, 1, 0, 0, 0, 5299, 5297, 1, 0, 0,
		0, 5300, 5301, 3, 608, 304, 0, 5301, 5302, 3, 610, 305, 0, 5302, 5303,
		3, 612, 306, 0, 5303, 5304, 3, 614, 307, 0, 5304, 5312, 1, 0, 0, 0, 5305,
		5306, 3, 608, 304, 0, 5306, 5307, 3, 524, 262, 0, 5307, 5308, 3, 116, 58,
		0, 5308, 5309, 3, 612, 306, 0, 5309, 5310, 3, 614, 307, 0, 5310, 5312,
		1, 0, 0, 0, 5311, 5300, 1, 0, 0, 0, 5311, 5305, 1, 0, 0, 0, 5312, 601,
		1, 0, 0, 0, 5313, 5314, 3, 1372, 686, 0, 5314, 5315, 3, 600, 300, 0, 5315,
		5325, 1, 0, 0, 0, 5316, 5317, 3, 1214, 607, 0, 5317, 5318, 3, 600, 300,
		0, 5318, 5325, 1, 0, 0, 0, 5319, 5320, 5, 2, 0, 0, 5320, 5321, 3, 1162,
		581, 0, 5321, 5322, 5, 3, 0, 0, 5322, 5323, 3, 600, 300, 0, 5323, 5325,
		1, 0, 0, 0, 5324, 5313, 1, 0, 0, 0, 5324, 5316, 1, 0, 0, 0, 5324, 5319,
		1, 0, 0, 0, 5325, 603, 1, 0, 0, 0, 5326, 5327, 5, 441, 0, 0, 5327, 5328,
		5, 2, 0, 0, 5328, 5329, 3, 606, 303, 0, 5329, 5330, 5, 3, 0, 0, 5330, 5333,
		1, 0, 0, 0, 5331, 5333, 1, 0, 0, 0, 5332, 5326, 1, 0, 0, 0, 5332, 5331,
		1, 0, 0, 0, 5333, 605, 1, 0, 0, 0, 5334, 5339, 3, 602, 301, 0, 5335, 5336,
		5, 6, 0, 0, 5336, 5338, 3, 602, 301, 0, 5337, 5335, 1, 0, 0, 0, 5338, 5341,
		1, 0, 0, 0, 5339, 5337, 1, 0, 0, 0, 5339, 5340, 1, 0, 0, 0, 5340, 607,
		1, 0, 0, 0, 5341, 5339, 1, 0, 0, 0, 5342, 5343, 5, 43, 0, 0, 5343, 5346,
		3, 524, 262, 0, 5344, 5346, 1, 0, 0, 0, 5345, 5342, 1, 0, 0, 0, 5345, 5344,
		1, 0, 0, 0, 5346, 609, 1, 0, 0, 0, 5347, 5350, 3, 524, 262, 0, 5348, 5350,
		1, 0, 0, 0, 5349, 5347, 1, 0, 0, 0, 5349, 5348, 1, 0, 0, 0, 5350, 611,
		1, 0, 0, 0, 5351, 5355, 5, 37, 0, 0, 5352, 5355, 5, 55, 0, 0, 5353, 5355,
		1, 0, 0, 0, 5354, 5351, 1, 0, 0, 0, 5354, 5352, 1, 0, 0, 0, 5354, 5353,
		1, 0, 0, 0, 5355, 613, 1, 0, 0, 0, 5356, 5357, 5, 266, 0, 0, 5357, 5362,
		5, 207, 0, 0, 5358, 5359, 5, 266, 0, 0, 5359, 5362, 5, 240, 0, 0, 5360,
		5362, 1, 0, 0, 0, 5361, 5356, 1, 0, 0, 0, 5361, 5358, 1, 0, 0, 0, 5361,
		5360, 1, 0, 0, 0, 5362, 615, 1, 0, 0, 0, 5363, 5364, 5, 46, 0, 0, 5364,
		5365, 3, 618, 309, 0, 5365, 5366, 7, 22, 0, 0, 5366, 5367, 3, 1346, 673,
		0, 5367, 5377, 3, 628, 314, 0, 5368, 5375, 5, 309, 0, 0, 5369, 5376, 3,
		638, 319, 0, 5370, 5371, 5, 92, 0, 0, 5371, 5372, 5, 2, 0, 0, 5372, 5373,
		3, 668, 334, 0, 5373, 5374, 5, 3, 0, 0, 5374, 5376, 1, 0, 0, 0, 5375, 5369,
		1, 0, 0, 0, 5375, 5370, 1, 0, 0, 0, 5376, 5378, 1, 0, 0, 0, 5377, 5368,
		1, 0, 0, 0, 5377, 5378, 1, 0, 0, 0, 5378, 5379, 1, 0, 0, 0, 5379, 5380,
		3, 654, 327, 0, 5380, 617, 1, 0, 0, 0, 5381, 5382, 5, 82, 0, 0, 5382, 5385,
		5, 304, 0, 0, 5383, 5385, 1, 0, 0, 0, 5384, 5381, 1, 0, 0, 0, 5384, 5383,
		1, 0, 0, 0, 5385, 619, 1, 0, 0, 0, 5386, 5388, 5, 2, 0, 0, 5387, 5389,
		3, 622, 311, 0, 5388, 5387, 1, 0, 0, 0, 5388, 5389, 1, 0, 0, 0, 5389, 5390,
		1, 0, 0, 0, 5390, 5391, 5, 3, 0, 0, 5391, 621, 1, 0, 0, 0, 5392, 5397,
		3, 632, 316, 0, 5393, 5394, 5, 6, 0, 0, 5394, 5396, 3, 632, 316, 0, 5395,
		5393, 1, 0, 0, 0, 5396, 5399, 1, 0, 0, 0, 5397, 5395, 1, 0, 0, 0, 5397,
		5398, 1, 0, 0, 0, 5398, 623, 1, 0, 0, 0, 5399, 5397, 1, 0, 0, 0, 5400,
		5405, 3, 626, 313, 0, 5401, 5402, 5, 6, 0, 0, 5402, 5404, 3, 626, 313,
		0, 5403, 5401, 1, 0, 0, 0, 5404, 5407, 1, 0, 0, 0, 5405, 5403, 1, 0, 0,
		0, 5405, 5406, 1, 0, 0, 0, 5406, 625, 1, 0, 0, 0, 5407, 5405, 1, 0, 0,
		0, 5408, 5409, 3, 1346, 673, 0, 5409, 5410, 3, 620, 310, 0, 5410, 5417,
		1, 0, 0, 0, 5411, 5417, 3, 1390, 695, 0, 5412, 5414, 3, 1372, 686, 0, 5413,
		5415, 3, 1324, 662, 0, 5414, 5413, 1, 0, 0, 0, 5414, 5415, 1, 0, 0, 0,
		5415, 5417, 1, 0, 0, 0, 5416, 5408, 1, 0, 0, 0, 5416, 5411, 1, 0, 0, 0,
		5416, 5412, 1, 0, 0, 0, 5417, 627, 1, 0, 0, 0, 5418, 5420, 5, 2, 0, 0,
		5419, 5421, 3, 630, 315, 0, 5420, 5419, 1, 0, 0, 0, 5420, 5421, 1, 0, 0,
		0, 5421, 5422, 1, 0, 0, 0, 5422, 5423, 5, 3, 0, 0, 5423, 629, 1, 0, 0,
		0, 5424, 5429, 3, 642, 321, 0, 5425, 5426, 5, 6, 0, 0, 5426, 5428, 3, 642,
		321, 0, 5427, 5425, 1, 0, 0, 0, 5428, 5431, 1, 0, 0, 0, 5429, 5427, 1,
		0, 0, 0, 5429, 5430, 1, 0, 0, 0, 5430, 631, 1, 0, 0, 0, 5431, 5429, 1,
		0, 0, 0, 5432, 5434, 3, 634, 317, 0, 5433, 5435, 3, 636, 318, 0, 5434,
		5433, 1, 0, 0, 0, 5434, 5435, 1, 0, 0, 0, 5435, 5436, 1, 0, 0, 0, 5436,
		5437, 3, 640, 320, 0, 5437, 5446, 1, 0, 0, 0, 5438, 5440, 3, 636, 318,
		0, 5439, 5441, 3, 634, 317, 0, 5440, 5439, 1, 0, 0, 0, 5440, 5441, 1, 0,
		0, 0, 5441, 5442, 1, 0, 0, 0, 5442, 5443, 3, 640, 320, 0, 5443, 5446, 1,
		0, 0, 0, 5444, 5446, 3, 640, 320, 0, 5445, 5432, 1, 0, 0, 0, 5445, 5438,
		1, 0, 0, 0, 5445, 5444, 1, 0, 0, 0, 5446, 633, 1, 0, 0, 0, 5447, 5449,
		5, 68, 0, 0, 5448, 5450, 5, 453, 0, 0, 5449, 5448, 1, 0, 0, 0, 5449, 5450,
		1, 0, 0, 0, 5450, 5455, 1, 0, 0, 0, 5451, 5455, 5, 453, 0, 0, 5452, 5455,
		5, 393, 0, 0, 5453, 5455, 5, 101, 0, 0, 5454, 5447, 1, 0, 0, 0, 5454, 5451,
		1, 0, 0, 0, 5454, 5452, 1, 0, 0, 0, 5454, 5453, 1, 0, 0, 0, 5455, 635,
		1, 0, 0, 0, 5456, 5461, 3, 1376, 688, 0, 5457, 5461, 3, 1394, 697, 0, 5458,
		5461, 5, 119, 0, 0, 5459, 5461, 5, 126, 0, 0, 5460, 5456, 1, 0, 0, 0, 5460,
		5457, 1, 0, 0, 0, 5460, 5458, 1, 0, 0, 0, 5460, 5459, 1, 0, 0, 0, 5461,
		637, 1, 0, 0, 0, 5462, 5463, 3, 640, 320, 0, 5463, 639, 1, 0, 0, 0, 5464,
		5479, 3, 1118, 559, 0, 5465, 5467, 5, 408, 0, 0, 5466, 5465, 1, 0, 0, 0,
		5466, 5467, 1, 0, 0, 0, 5467, 5472, 1, 0, 0, 0, 5468, 5473, 3, 1394, 697,
		0, 5469, 5473, 3, 1376, 688, 0, 5470, 5473, 5, 119, 0, 0, 5471, 5473, 5,
		126, 0, 0, 5472, 5468, 1, 0, 0, 0, 5472, 5469, 1, 0, 0, 0, 5472, 5470,
		1, 0, 0, 0, 5472, 5471, 1, 0, 0, 0, 5473, 5474, 1, 0, 0, 0, 5474, 5475,
		3, 526, 263, 0, 5475, 5476, 5, 27, 0, 0, 5476, 5477, 5, 353, 0, 0, 5477,
		5479, 1, 0, 0, 0, 5478, 5464, 1, 0, 0, 0, 5478, 5466, 1, 0, 0, 0, 5479,
		641, 1, 0, 0, 0, 5480, 5483, 3, 632, 316, 0, 5481, 5482, 7, 26, 0, 0, 5482,
		5484, 3, 1162, 581, 0, 5483, 5481, 1, 0, 0, 0, 5483, 5484, 1, 0, 0, 0,
		5484, 643, 1, 0, 0, 0, 5485, 5486, 3, 632, 316, 0, 5486, 645, 1, 0, 0,
		0, 5487, 5498, 5, 2, 0, 0, 5488, 5499, 5, 9, 0, 0, 5489, 5499, 3, 648,
		324, 0, 5490, 5491, 5, 83, 0, 0, 5491, 5492, 5, 147, 0, 0, 5492, 5499,
		3, 648, 324, 0, 5493, 5494, 3, 648, 324, 0, 5494, 5495, 5, 83, 0, 0, 5495,
		5496, 5, 147, 0, 0, 5496, 5497, 3, 648, 324, 0, 5497, 5499, 1, 0, 0, 0,
		5498, 5488, 1, 0, 0, 0, 5498, 5489, 1, 0, 0, 0, 5498, 5490, 1, 0, 0, 0,
		5498, 5493, 1, 0, 0, 0, 5499, 5500, 1, 0, 0, 0, 5500, 5501, 5, 3, 0, 0,
		5501, 647, 1, 0, 0, 0, 5502, 5507, 3, 644, 322, 0, 5503, 5504, 5, 6, 0,
		0, 5504, 5506, 3, 644, 322, 0, 5505, 5503, 1, 0, 0, 0, 5506, 5509, 1, 0,
		0, 0, 5507, 5505, 1, 0, 0, 0, 5507, 5508, 1, 0, 0, 0, 5508, 649, 1, 0,
		0, 0, 5509, 5507, 1, 0, 0, 0, 5510, 5511, 3, 1346, 673, 0, 5511, 5512,
		3, 646, 323, 0, 5512, 651, 1, 0, 0, 0, 5513, 5518, 3, 650, 325, 0, 5514,
		5515, 5, 6, 0, 0, 5515, 5517, 3, 650, 325, 0, 5516, 5514, 1, 0, 0, 0, 5517,
		5520, 1, 0, 0, 0, 5518, 5516, 1, 0, 0, 0, 5518, 5519, 1, 0, 0, 0, 5519,
		653, 1, 0, 0, 0, 5520, 5518, 1, 0, 0, 0, 5521, 5523, 3, 658, 329, 0, 5522,
		5521, 1, 0, 0, 0, 5523, 5524, 1, 0, 0, 0, 5524, 5522, 1, 0, 0, 0, 5524,
		5525, 1, 0, 0, 0, 5525, 5526, 1, 0, 0, 0, 5526, 5527, 6, 327, -1, 0, 5527,
		655, 1, 0, 0, 0, 5528, 5529, 5, 149, 0, 0, 5529, 5530, 5, 80, 0, 0, 5530,
		5531, 5, 78, 0, 0, 5531, 5564, 5, 458, 0, 0, 5532, 5533, 5, 309, 0, 0,
		5533, 5534, 5, 78, 0, 0, 5534, 5535, 5, 80, 0, 0, 5535, 5536, 5, 78, 0,
		0, 5536, 5564, 5, 458, 0, 0, 5537, 5564, 5, 339, 0, 0, 5538, 5564, 5, 222,
		0, 0, 5539, 5564, 5, 331, 0, 0, 5540, 5564, 5, 370, 0, 0, 5541, 5542, 5,
		205, 0, 0, 5542, 5543, 5, 320, 0, 0, 5543, 5564, 5, 181, 0, 0, 5544, 5545,
		5, 205, 0, 0, 5545, 5546, 5, 320, 0, 0, 5546, 5564, 5, 234, 0, 0, 5547,
		5548, 5, 320, 0, 0, 5548, 5564, 5, 181, 0, 0, 5549, 5550, 5, 320, 0, 0,
		5550, 5564, 5, 234, 0, 0, 5551, 5564, 5, 241, 0, 0, 5552, 5553, 5, 77,
		0, 0, 5553, 5564, 5, 241, 0, 0, 5554, 5555, 5, 170, 0, 0, 5555, 5564, 3,
		292, 146, 0, 5556, 5557, 5, 313, 0, 0, 5557, 5564, 3, 292, 146, 0, 5558,
		5559, 5, 459, 0, 0, 5559, 5564, 3, 524, 262, 0, 5560, 5564, 3, 82, 41,
		0, 5561, 5562, 5, 460, 0, 0, 5562, 5564, 3, 1372, 686, 0, 5563, 5528, 1,
		0, 0, 0, 5563, 5532, 1, 0, 0, 0, 5563, 5537, 1, 0, 0, 0, 5563, 5538, 1,
		0, 0, 0, 5563, 5539, 1, 0, 0, 0, 5563, 5540, 1, 0, 0, 0, 5563, 5541, 1,
		0, 0, 0, 5563, 5544, 1, 0, 0, 0, 5563, 5547, 1, 0, 0, 0, 5563, 5549, 1,
		0, 0, 0, 5563, 5551, 1, 0, 0, 0, 5563, 5552, 1, 0, 0, 0, 5563, 5554, 1,
		0, 0, 0, 5563, 5556, 1, 0, 0, 0, 5563, 5558, 1, 0, 0, 0, 5563, 5560, 1,
		0, 0, 0, 5563, 5561, 1, 0, 0, 0, 5564, 657, 1, 0, 0, 0, 5565, 5566, 5,
		36, 0, 0, 5566, 5574, 3, 660, 330, 0, 5567, 5568, 5, 238, 0, 0, 5568, 5574,
		3, 72, 36, 0, 5569, 5570, 5, 443, 0, 0, 5570, 5574, 3, 662, 331, 0, 5571,
		5574, 5, 104, 0, 0, 5572, 5574, 3, 656, 328, 0, 5573, 5565, 1, 0, 0, 0,
		5573, 5567, 1, 0, 0, 0, 5573, 5569, 1, 0, 0, 0, 5573, 5571, 1, 0, 0, 0,
		5573, 5572, 1, 0, 0, 0, 5574, 659, 1, 0, 0, 0, 5575, 5581, 3, 1358, 679,
		0, 5576, 5577, 3, 1358, 679, 0, 5577, 5578, 5, 6, 0, 0, 5578, 5579, 3,
		1358, 679, 0, 5579, 5581, 1, 0, 0, 0, 5580, 5575, 1, 0, 0, 0, 5580, 5576,
		1, 0, 0, 0, 5581, 661, 1, 0, 0, 0, 5582, 5583, 5, 62, 0, 0, 5583, 5584,
		5, 353, 0, 0, 5584, 5591, 3, 1118, 559, 0, 5585, 5586, 5, 6, 0, 0, 5586,
		5587, 5, 62, 0, 0, 5587, 5588, 5, 353, 0, 0, 5588, 5590, 3, 1118, 559,
		0, 5589, 5585, 1, 0, 0, 0, 5590, 5593, 1, 0, 0, 0, 5591, 5589, 1, 0, 0,
		0, 5591, 5592, 1, 0, 0, 0, 5592, 663, 1, 0, 0, 0, 5593, 5591, 1, 0, 0,
		0, 5594, 5595, 5, 105, 0, 0, 5595, 5598, 3, 460, 230, 0, 5596, 5598, 1,
		0, 0, 0, 5597, 5594, 1, 0, 0, 0, 5597, 5596, 1, 0, 0, 0, 5598, 665, 1,
		0, 0, 0, 5599, 5600, 3, 636, 318, 0, 5600, 5601, 3, 640, 320, 0, 5601,
		667, 1, 0, 0, 0, 5602, 5607, 3, 666, 333, 0, 5603, 5604, 5, 6, 0, 0, 5604,
		5606, 3, 666, 333, 0, 5605, 5603, 1, 0, 0, 0, 5606, 5609, 1, 0, 0, 0, 5607,
		5605, 1, 0, 0, 0, 5607, 5608, 1, 0, 0, 0, 5608, 669, 1, 0, 0, 0, 5609,
		5607, 1, 0, 0, 0, 5610, 5611, 5, 138, 0, 0, 5611, 5612, 7, 27, 0, 0, 5612,
		5613, 3, 626, 313, 0, 5613, 5614, 3, 672, 336, 0, 5614, 5615, 3, 674, 337,
		0, 5615, 671, 1, 0, 0, 0, 5616, 5618, 3, 656, 328, 0, 5617, 5616, 1, 0,
		0, 0, 5618, 5619, 1, 0, 0, 0, 5619, 5617, 1, 0, 0, 0, 5619, 5620, 1, 0,
		0, 0, 5620, 673, 1, 0, 0, 0, 5621, 5624, 5, 308, 0, 0, 5622, 5624, 1, 0,
		0, 0, 5623, 5621, 1, 0, 0, 0, 5623, 5622, 1, 0, 0, 0, 5624, 675, 1, 0,
		0, 0, 5625, 5626, 5, 191, 0, 0, 5626, 5627, 5, 211, 0, 0, 5627, 5628, 3,
		624, 312, 0, 5628, 5629, 3, 108, 54, 0, 5629, 5662, 1, 0, 0, 0, 5630, 5631,
		5, 191, 0, 0, 5631, 5632, 5, 211, 0, 0, 5632, 5633, 5, 220, 0, 0, 5633,
		5634, 5, 389, 0, 0, 5634, 5635, 3, 624, 312, 0, 5635, 5636, 3, 108, 54,
		0, 5636, 5662, 1, 0, 0, 0, 5637, 5638, 5, 191, 0, 0, 5638, 5639, 5, 289,
		0, 0, 5639, 5640, 3, 624, 312, 0, 5640, 5641, 3, 108, 54, 0, 5641, 5662,
		1, 0, 0, 0, 5642, 5643, 5, 191, 0, 0, 5643, 5644, 5, 289, 0, 0, 5644, 5645,
		5, 220, 0, 0, 5645, 5646, 5, 389, 0, 0, 5646, 5647, 3, 624, 312, 0, 5647,
		5648, 3, 108, 54, 0, 5648, 5662, 1, 0, 0, 0, 5649, 5650, 5, 191, 0, 0,
		5650, 5651, 5, 442, 0, 0, 5651, 5652, 3, 624, 312, 0, 5652, 5653, 3, 108,
		54, 0, 5653, 5662, 1, 0, 0, 0, 5654, 5655, 5, 191, 0, 0, 5655, 5656, 5,
		442, 0, 0, 5656, 5657, 5, 220, 0, 0, 5657, 5658, 5, 389, 0, 0, 5658, 5659,
		3, 624, 312, 0, 5659, 5660, 3, 108, 54, 0, 5660, 5662, 1, 0, 0, 0, 5661,
		5625, 1, 0, 0, 0, 5661, 5630, 1, 0, 0, 0, 5661, 5637, 1, 0, 0, 0, 5661,
		5642, 1, 0, 0, 0, 5661, 5649, 1, 0, 0, 0, 5661, 5654, 1, 0, 0, 0, 5662,
		677, 1, 0, 0, 0, 5663, 5664, 5, 191, 0, 0, 5664, 5665, 5, 136, 0, 0, 5665,
		5666, 3, 652, 326, 0, 5666, 5667, 3, 108, 54, 0, 5667, 5676, 1, 0, 0, 0,
		5668, 5669, 5, 191, 0, 0, 5669, 5670, 5, 136, 0, 0, 5670, 5671, 5, 220,
		0, 0, 5671, 5672, 5, 389, 0, 0, 5672, 5673, 3, 652, 326, 0, 5673, 5674,
		3, 108, 54, 0, 5674, 5676, 1, 0, 0, 0, 5675, 5663, 1, 0, 0, 0, 5675, 5668,
		1, 0, 0, 0, 5676, 679, 1, 0, 0, 0, 5677, 5678, 5, 191, 0, 0, 5678, 5679,
		5, 271, 0, 0, 5679, 5680, 3, 686, 343, 0, 5680, 5681, 3, 108, 54, 0, 5681,
		5690, 1, 0, 0, 0, 5682, 5683, 5, 191, 0, 0, 5683, 5684, 5, 271, 0, 0, 5684,
		5685, 5, 220, 0, 0, 5685, 5686, 5, 389, 0, 0, 5686, 5687, 3, 686, 343,
		0, 5687, 5688, 3, 108, 54, 0, 5688, 5690, 1, 0, 0, 0, 5689, 5677, 1, 0,
		0, 0, 5689, 5682, 1, 0, 0, 0, 5690, 681, 1, 0, 0, 0, 5691, 5692, 5, 2,
		0, 0, 5692, 5693, 3, 1118, 559, 0, 5693, 5694, 5, 3, 0, 0, 5694, 5714,
		1, 0, 0, 0, 5695, 5696, 5, 2, 0, 0, 5696, 5697, 3, 1118, 559, 0, 5697,
		5698, 5, 6, 0, 0, 5698, 5699, 3, 1118, 559, 0, 5699, 5700, 5, 3, 0, 0,
		5700, 5714, 1, 0, 0, 0, 5701, 5702, 5, 2, 0, 0, 5702, 5703, 5, 400, 0,
		0, 5703, 5704, 5, 6, 0, 0, 5704, 5705, 3, 1118, 559, 0, 5705, 5706, 5,
		3, 0, 0, 5706, 5714, 1, 0, 0, 0, 5707, 5708, 5, 2, 0, 0, 5708, 5709, 3,
		1118, 559, 0, 5709, 5710, 5, 6, 0, 0, 5710, 5711, 5, 400, 0, 0, 5711, 5712,
		5, 3, 0, 0, 5712, 5714, 1, 0, 0, 0, 5713, 5691, 1, 0, 0, 0, 5713, 5695,
		1, 0, 0, 0, 5713, 5701, 1, 0, 0, 0, 5713, 5707, 1, 0, 0, 0, 5714, 683,
		1, 0, 0, 0, 5715, 5716, 3, 1372, 686, 0, 5716, 5717, 5, 11, 0, 0, 5717,
		5719, 1, 0, 0, 0, 5718, 5715, 1, 0, 0, 0, 5719, 5722, 1, 0, 0, 0, 5720,
		5718, 1, 0, 0, 0, 5720, 5721, 1, 0, 0, 0, 5721, 5723, 1, 0, 0, 0, 5722,
		5720, 1, 0, 0, 0, 5723, 5724, 3, 1270, 635, 0, 5724, 685, 1, 0, 0, 0, 5725,
		5730, 3, 688, 344, 0, 5726, 5727, 5, 6, 0, 0, 5727, 5729, 3, 688, 344,
		0, 5728, 5726, 1, 0, 0, 0, 5729, 5732, 1, 0, 0, 0, 5730, 5728, 1, 0, 0,
		0, 5730, 5731, 1, 0, 0, 0, 5731, 687, 1, 0, 0, 0, 5732, 5730, 1, 0, 0,
		0, 5733, 5734, 3, 684, 342, 0, 5734, 5735, 3, 682, 341, 0, 5735, 689, 1,
		0, 0, 0, 5736, 5737, 5, 57, 0, 0, 5737, 5738, 3, 692, 346, 0, 5738, 691,
		1, 0, 0, 0, 5739, 5741, 3, 694, 347, 0, 5740, 5739, 1, 0, 0, 0, 5741, 5742,
		1, 0, 0, 0, 5742, 5740, 1, 0, 0, 0, 5742, 5743, 1, 0, 0, 0, 5743, 693,
		1, 0, 0, 0, 5744, 5748, 3, 1358, 679, 0, 5745, 5746, 5, 238, 0, 0, 5746,
		5748, 3, 72, 36, 0, 5747, 5744, 1, 0, 0, 0, 5747, 5745, 1, 0, 0, 0, 5748,
		695, 1, 0, 0, 0, 5749, 5750, 5, 46, 0, 0, 5750, 5751, 5, 41, 0, 0, 5751,
		5752, 5, 2, 0, 0, 5752, 5753, 3, 1118, 559, 0, 5753, 5754, 5, 36, 0, 0,
		5754, 5755, 3, 1118, 559, 0, 5755, 5756, 5, 3, 0, 0, 5756, 5757, 5, 105,
		0, 0, 5757, 5758, 5, 211, 0, 0, 5758, 5759, 3, 626, 313, 0, 5759, 5760,
		3, 698, 349, 0, 5760, 5784, 1, 0, 0, 0, 5761, 5762, 5, 46, 0, 0, 5762,
		5763, 5, 41, 0, 0, 5763, 5764, 5, 2, 0, 0, 5764, 5765, 3, 1118, 559, 0,
		5765, 5766, 5, 36, 0, 0, 5766, 5767, 3, 1118, 559, 0, 5767, 5768, 5, 3,
		0, 0, 5768, 5769, 5, 372, 0, 0, 5769, 5770, 5, 211, 0, 0, 5770, 5771, 3,
		698, 349, 0, 5771, 5784, 1, 0, 0, 0, 5772, 5773, 5, 46, 0, 0, 5773, 5774,
		5, 41, 0, 0, 5774, 5775, 5, 2, 0, 0, 5775, 5776, 3, 1118, 559, 0, 5776,
		5777, 5, 36, 0, 0, 5777, 5778, 3, 1118, 559, 0, 5778, 5779, 5, 3, 0, 0,
		5779, 5780, 5, 105, 0, 0, 5780, 5781, 5, 393, 0, 0, 5781, 5782, 3, 698,
		349, 0, 5782, 5784, 1, 0, 0, 0, 5783, 5749, 1, 0, 0, 0, 5783, 5761, 1,
		0, 0, 0, 5783, 5772, 1, 0, 0, 0, 5784, 697, 1, 0, 0, 0, 5785, 5786, 5,
		36, 0, 0, 5786, 5791, 5, 223, 0, 0, 5787, 5788, 5, 36, 0, 0, 5788, 5791,
		5, 141, 0, 0, 5789, 5791, 1, 0, 0, 0, 5790, 5785, 1, 0, 0, 0, 5790, 5787,
		1, 0, 0, 0, 5790, 5789, 1, 0, 0, 0, 5791, 699, 1, 0, 0, 0, 5792, 5793,
		5, 191, 0, 0, 5793, 5794, 5, 41, 0, 0, 5794, 5795, 3, 702, 351, 0, 5795,
		5796, 5, 2, 0, 0, 5796, 5797, 3, 1118, 559, 0, 5797, 5798, 5, 36, 0, 0,
		5798, 5799, 3, 1118, 559, 0, 5799, 5800, 5, 3, 0, 0, 5800, 5801, 3, 108,
		54, 0, 5801, 701, 1, 0, 0, 0, 5802, 5803, 5, 220, 0, 0, 5803, 5806, 5,
		389, 0, 0, 5804, 5806, 1, 0, 0, 0, 5805, 5802, 1, 0, 0, 0, 5805, 5804,
		1, 0, 0, 0, 5806, 703, 1, 0, 0, 0, 5807, 5808, 5, 46, 0, 0, 5808, 5809,
		3, 618, 309, 0, 5809, 5810, 5, 443, 0, 0, 5810, 5811, 5, 62, 0, 0, 5811,
		5812, 3, 1118, 559, 0, 5812, 5813, 5, 238, 0, 0, 5813, 5814, 3, 1340, 670,
		0, 5814, 5815, 5, 2, 0, 0, 5815, 5816, 3, 706, 353, 0, 5816, 5817, 5, 3,
		0, 0, 5817, 705, 1, 0, 0, 0, 5818, 5819, 5, 64, 0, 0, 5819, 5820, 5, 461,
		0, 0, 5820, 5821, 5, 105, 0, 0, 5821, 5822, 5, 211, 0, 0, 5822, 5823, 3,
		626, 313, 0, 5823, 5824, 5, 6, 0, 0, 5824, 5825, 5, 94, 0, 0, 5825, 5826,
		5, 461, 0, 0, 5826, 5827, 5, 105, 0, 0, 5827, 5828, 5, 211, 0, 0, 5828,
		5829, 3, 626, 313, 0, 5829, 5853, 1, 0, 0, 0, 5830, 5831, 5, 94, 0, 0,
		5831, 5832, 5, 461, 0, 0, 5832, 5833, 5, 105, 0, 0, 5833, 5834, 5, 211,
		0, 0, 5834, 5835, 3, 626, 313, 0, 5835, 5836, 5, 6, 0, 0, 5836, 5837, 5,
		64, 0, 0, 5837, 5838, 5, 461, 0, 0, 5838, 5839, 5, 105, 0, 0, 5839, 5840,
		5, 211, 0, 0, 5840, 5841, 3, 626, 313, 0, 5841, 5853, 1, 0, 0, 0, 5842,
		5843, 5, 64, 0, 0, 5843, 5844, 5, 461, 0, 0, 5844, 5845, 5, 105, 0, 0,
		5845, 5846, 5, 211, 0, 0, 5846, 5853, 3, 626, 313, 0, 5847, 5848, 5, 94,
		0, 0, 5848, 5849, 5, 461, 0, 0, 5849, 5850, 5, 105, 0, 0, 5850, 5851, 5,
		211, 0, 0, 5851, 5853, 3, 626, 313, 0, 5852, 5818, 1, 0, 0, 0, 5852, 5830,
		1, 0, 0, 0, 5852, 5842, 1, 0, 0, 0, 5852, 5847, 1, 0, 0, 0, 5853, 707,
		1, 0, 0, 0, 5854, 5855, 5, 191, 0, 0, 5855, 5856, 5, 443, 0, 0, 5856, 5857,
		3, 702, 351, 0, 5857, 5858, 5, 62, 0, 0, 5858, 5859, 3, 1118, 559, 0, 5859,
		5860, 5, 238, 0, 0, 5860, 5861, 3, 1340, 670, 0, 5861, 5862, 3, 108, 54,
		0, 5862, 709, 1, 0, 0, 0, 5863, 5864, 5, 299, 0, 0, 5864, 5865, 3, 712,
		356, 0, 5865, 5866, 3, 592, 296, 0, 5866, 5867, 3, 1336, 668, 0, 5867,
		5890, 1, 0, 0, 0, 5868, 5869, 5, 299, 0, 0, 5869, 5870, 3, 714, 357, 0,
		5870, 5871, 3, 592, 296, 0, 5871, 5872, 3, 1340, 670, 0, 5872, 5890, 1,
		0, 0, 0, 5873, 5874, 5, 299, 0, 0, 5874, 5875, 5, 2, 0, 0, 5875, 5876,
		3, 716, 358, 0, 5876, 5877, 5, 3, 0, 0, 5877, 5878, 3, 712, 356, 0, 5878,
		5879, 3, 592, 296, 0, 5879, 5880, 3, 1336, 668, 0, 5880, 5890, 1, 0, 0,
		0, 5881, 5882, 5, 299, 0, 0, 5882, 5883, 5, 2, 0, 0, 5883, 5884, 3, 716,
		358, 0, 5884, 5885, 5, 3, 0, 0, 5885, 5886, 3, 714, 357, 0, 5886, 5887,
		3, 592, 296, 0, 5887, 5888, 3, 1340, 670, 0, 5888, 5890, 1, 0, 0, 0, 5889,
		5863, 1, 0, 0, 0, 5889, 5868, 1, 0, 0, 0, 5889, 5873, 1, 0, 0, 0, 5889,
		5881, 1, 0, 0, 0, 5890, 711, 1, 0, 0, 0, 5891, 5892, 7, 28, 0, 0, 5892,
		713, 1, 0, 0, 0, 5893, 5894, 7, 29, 0, 0, 5894, 715, 1, 0, 0, 0, 5895,
		5900, 3, 718, 359, 0, 5896, 5897, 5, 6, 0, 0, 5897, 5899, 3, 718, 359,
		0, 5898, 5896, 1, 0, 0, 0, 5899, 5902, 1, 0, 0, 0, 5900, 5898, 1, 0, 0,
		0, 5900, 5901, 1, 0, 0, 0, 5901, 717, 1, 0, 0, 0, 5902, 5900, 1, 0, 0,
		0, 5903, 5904, 7, 30, 0, 0, 5904, 719, 1, 0, 0, 0, 5905, 5906, 5, 138,
		0, 0, 5906, 5907, 5, 344, 0, 0, 5907, 5908, 3, 1340, 670, 0, 5908, 5909,
		5, 326, 0, 0, 5909, 5910, 3, 116, 58, 0, 5910, 5918, 1, 0, 0, 0, 5911,
		5912, 5, 138, 0, 0, 5912, 5913, 5, 344, 0, 0, 5913, 5914, 3, 1340, 670,
		0, 5914, 5915, 5, 306, 0, 0, 5915, 5916, 3, 116, 58, 0, 5916, 5918, 1,
		0, 0, 0, 5917, 5905, 1, 0, 0, 0, 5917, 5911, 1, 0, 0, 0, 5918, 721, 1,
		0, 0, 0, 5919, 5920, 5, 138, 0, 0, 5920, 5921, 5, 136, 0, 0, 5921, 5922,
		3, 650, 325, 0, 5922, 5923, 5, 302, 0, 0, 5923, 5924, 5, 94, 0, 0, 5924,
		5925, 3, 1340, 670, 0, 5925, 6388, 1, 0, 0, 0, 5926, 5927, 5, 138, 0, 0,
		5927, 5928, 5, 108, 0, 0, 5928, 5929, 3, 524, 262, 0, 5929, 5930, 5, 302,
		0, 0, 5930, 5931, 5, 94, 0, 0, 5931, 5932, 3, 1340, 670, 0, 5932, 6388,
		1, 0, 0, 0, 5933, 5934, 5, 138, 0, 0, 5934, 5935, 5, 168, 0, 0, 5935, 5936,
		3, 524, 262, 0, 5936, 5937, 5, 302, 0, 0, 5937, 5938, 5, 94, 0, 0, 5938,
		5939, 3, 1340, 670, 0, 5939, 6388, 1, 0, 0, 0, 5940, 5941, 5, 138, 0, 0,
		5941, 5942, 5, 175, 0, 0, 5942, 5943, 3, 1340, 670, 0, 5943, 5944, 5, 302,
		0, 0, 5944, 5945, 5, 94, 0, 0, 5945, 5946, 3, 1340, 670, 0, 5946, 6388,
		1, 0, 0, 0, 5947, 5948, 5, 138, 0, 0, 5948, 5949, 5, 189, 0, 0, 5949, 5950,
		3, 524, 262, 0, 5950, 5951, 5, 302, 0, 0, 5951, 5952, 5, 94, 0, 0, 5952,
		5953, 3, 1340, 670, 0, 5953, 6388, 1, 0, 0, 0, 5954, 5955, 5, 138, 0, 0,
		5955, 5956, 5, 189, 0, 0, 5956, 5957, 3, 524, 262, 0, 5957, 5958, 5, 302,
		0, 0, 5958, 5959, 5, 45, 0, 0, 5959, 5960, 3, 1340, 670, 0, 5960, 5961,
		5, 94, 0, 0, 5961, 5962, 3, 1340, 670, 0, 5962, 6388, 1, 0, 0, 0, 5963,
		5964, 5, 138, 0, 0, 5964, 5965, 5, 63, 0, 0, 5965, 5966, 5, 174, 0, 0,
		5966, 5967, 5, 374, 0, 0, 5967, 5968, 3, 1340, 670, 0, 5968, 5969, 5, 302,
		0, 0, 5969, 5970, 5, 94, 0, 0, 5970, 5971, 3, 1340, 670, 0, 5971, 6388,
		1, 0, 0, 0, 5972, 5973, 5, 138, 0, 0, 5973, 5974, 5, 211, 0, 0, 5974, 5975,
		3, 626, 313, 0, 5975, 5976, 5, 302, 0, 0, 5976, 5977, 5, 94, 0, 0, 5977,
		5978, 3, 1340, 670, 0, 5978, 6388, 1, 0, 0, 0, 5979, 5980, 5, 138, 0, 0,
		5980, 5981, 5, 66, 0, 0, 5981, 5982, 3, 1366, 683, 0, 5982, 5983, 5, 302,
		0, 0, 5983, 5984, 5, 94, 0, 0, 5984, 5985, 3, 1366, 683, 0, 5985, 6388,
		1, 0, 0, 0, 5986, 5987, 5, 138, 0, 0, 5987, 5988, 3, 308, 154, 0, 5988,
		5989, 5, 238, 0, 0, 5989, 5990, 3, 1340, 670, 0, 5990, 5991, 5, 302, 0,
		0, 5991, 5992, 5, 94, 0, 0, 5992, 5993, 3, 1340, 670, 0, 5993, 6388, 1,
		0, 0, 0, 5994, 5995, 5, 138, 0, 0, 5995, 5996, 5, 271, 0, 0, 5996, 5997,
		5, 156, 0, 0, 5997, 5998, 3, 524, 262, 0, 5998, 5999, 5, 100, 0, 0, 5999,
		6000, 3, 1340, 670, 0, 6000, 6001, 5, 302, 0, 0, 6001, 6002, 5, 94, 0,
		0, 6002, 6003, 3, 1340, 670, 0, 6003, 6388, 1, 0, 0, 0, 6004, 6005, 5,
		138, 0, 0, 6005, 6006, 5, 271, 0, 0, 6006, 6007, 5, 206, 0, 0, 6007, 6008,
		3, 524, 262, 0, 6008, 6009, 5, 100, 0, 0, 6009, 6010, 3, 1340, 670, 0,
		6010, 6011, 5, 302, 0, 0, 6011, 6012, 5, 94, 0, 0, 6012, 6013, 3, 1340,
		670, 0, 6013, 6388, 1, 0, 0, 0, 6014, 6015, 5, 138, 0, 0, 6015, 6016, 5,
		445, 0, 0, 6016, 6017, 3, 1340, 670, 0, 6017, 6018, 5, 80, 0, 0, 6018,
		6019, 3, 1336, 668, 0, 6019, 6020, 5, 302, 0, 0, 6020, 6021, 5, 94, 0,
		0, 6021, 6022, 3, 1340, 670, 0, 6022, 6388, 1, 0, 0, 0, 6023, 6024, 5,
		138, 0, 0, 6024, 6025, 5, 445, 0, 0, 6025, 6026, 5, 220, 0, 0, 6026, 6027,
		5, 389, 0, 0, 6027, 6028, 3, 1340, 670, 0, 6028, 6029, 5, 80, 0, 0, 6029,
		6030, 3, 1336, 668, 0, 6030, 6031, 5, 302, 0, 0, 6031, 6032, 5, 94, 0,
		0, 6032, 6033, 3, 1340, 670, 0, 6033, 6388, 1, 0, 0, 0, 6034, 6035, 5,
		138, 0, 0, 6035, 6036, 5, 289, 0, 0, 6036, 6037, 3, 626, 313, 0, 6037,
		6038, 5, 302, 0, 0, 6038, 6039, 5, 94, 0, 0, 6039, 6040, 3, 1340, 670,
		0, 6040, 6388, 1, 0, 0, 0, 6041, 6042, 5, 138, 0, 0, 6042, 6043, 5, 452,
		0, 0, 6043, 6044, 3, 1340, 670, 0, 6044, 6045, 5, 302, 0, 0, 6045, 6046,
		5, 94, 0, 0, 6046, 6047, 3, 1340, 670, 0, 6047, 6388, 1, 0, 0, 0, 6048,
		6049, 5, 138, 0, 0, 6049, 6050, 5, 442, 0, 0, 6050, 6051, 3, 626, 313,
		0, 6051, 6052, 5, 302, 0, 0, 6052, 6053, 5, 94, 0, 0, 6053, 6054, 3, 1340,
		670, 0, 6054, 6388, 1, 0, 0, 0, 6055, 6056, 5, 138, 0, 0, 6056, 6057, 5,
		316, 0, 0, 6057, 6058, 3, 1340, 670, 0, 6058, 6059, 5, 302, 0, 0, 6059,
		6060, 5, 94, 0, 0, 6060, 6061, 3, 1340, 670, 0, 6061, 6388, 1, 0, 0, 0,
		6062, 6063, 5, 138, 0, 0, 6063, 6064, 5, 324, 0, 0, 6064, 6065, 3, 1340,
		670, 0, 6065, 6066, 5, 302, 0, 0, 6066, 6067, 5, 94, 0, 0, 6067, 6068,
		3, 1340, 670, 0, 6068, 6388, 1, 0, 0, 0, 6069, 6070, 5, 138, 0, 0, 6070,
		6071, 5, 451, 0, 0, 6071, 6072, 3, 1340, 670, 0, 6072, 6073, 5, 302, 0,
		0, 6073, 6074, 5, 94, 0, 0, 6074, 6075, 3, 1340, 670, 0, 6075, 6388, 1,
		0, 0, 0, 6076, 6077, 5, 138, 0, 0, 6077, 6078, 5, 92, 0, 0, 6078, 6079,
		3, 1074, 537, 0, 6079, 6080, 5, 302, 0, 0, 6080, 6081, 5, 94, 0, 0, 6081,
		6082, 3, 1340, 670, 0, 6082, 6388, 1, 0, 0, 0, 6083, 6084, 5, 138, 0, 0,
		6084, 6085, 5, 92, 0, 0, 6085, 6086, 5, 220, 0, 0, 6086, 6087, 5, 389,
		0, 0, 6087, 6088, 3, 1074, 537, 0, 6088, 6089, 5, 302, 0, 0, 6089, 6090,
		5, 94, 0, 0, 6090, 6091, 3, 1340, 670, 0, 6091, 6388, 1, 0, 0, 0, 6092,
		6093, 5, 138, 0, 0, 6093, 6094, 5, 321, 0, 0, 6094, 6095, 3, 1336, 668,
		0, 6095, 6096, 5, 302, 0, 0, 6096, 6097, 5, 94, 0, 0, 6097, 6098, 3, 1340,
		670, 0, 6098, 6388, 1, 0, 0, 0, 6099, 6100, 5, 138, 0, 0, 6100, 6101, 5,
		321, 0, 0, 6101, 6102, 5, 220, 0, 0, 6102, 6103, 5, 389, 0, 0, 6103, 6104,
		3, 1336, 668, 0, 6104, 6105, 5, 302, 0, 0, 6105, 6106, 5, 94, 0, 0, 6106,
		6107, 3, 1340, 670, 0, 6107, 6388, 1, 0, 0, 0, 6108, 6109, 5, 138, 0, 0,
		6109, 6110, 5, 369, 0, 0, 6110, 6111, 3, 1336, 668, 0, 6111, 6112, 5, 302,
		0, 0, 6112, 6113, 5, 94, 0, 0, 6113, 6114, 3, 1340, 670, 0, 6114, 6388,
		1, 0, 0, 0, 6115, 6116, 5, 138, 0, 0, 6116, 6117, 5, 369, 0, 0, 6117, 6118,
		5, 220, 0, 0, 6118, 6119, 5, 389, 0, 0, 6119, 6120, 3, 1336, 668, 0, 6120,
		6121, 5, 302, 0, 0, 6121, 6122, 5, 94, 0, 0, 6122, 6123, 3, 1340, 670,
		0, 6123, 6388, 1, 0, 0, 0, 6124, 6125, 5, 138, 0, 0, 6125, 6126, 5, 251,
		0, 0, 6126, 6127, 5, 369, 0, 0, 6127, 6128, 3, 1336, 668, 0, 6128, 6129,
		5, 302, 0, 0, 6129, 6130, 5, 94, 0, 0, 6130, 6131, 3, 1340, 670, 0, 6131,
		6388, 1, 0, 0, 0, 6132, 6133, 5, 138, 0, 0, 6133, 6134, 5, 251, 0, 0, 6134,
		6135, 5, 369, 0, 0, 6135, 6136, 5, 220, 0, 0, 6136, 6137, 5, 389, 0, 0,
		6137, 6138, 3, 1336, 668, 0, 6138, 6139, 5, 302, 0, 0, 6139, 6140, 5, 94,
		0, 0, 6140, 6141, 3, 1340, 670, 0, 6141, 6388, 1, 0, 0, 0, 6142, 6143,
		5, 138, 0, 0, 6143, 6144, 5, 226, 0, 0, 6144, 6145, 3, 1336, 668, 0, 6145,
		6146, 5, 302, 0, 0, 6146, 6147, 5, 94, 0, 0, 6147, 6148, 3, 1340, 670,
		0, 6148, 6388, 1, 0, 0, 0, 6149, 6150, 5, 138, 0, 0, 6150, 6151, 5, 226,
		0, 0, 6151, 6152, 5, 220, 0, 0, 6152, 6153, 5, 389, 0, 0, 6153, 6154, 3,
		1336, 668, 0, 6154, 6155, 5, 302, 0, 0, 6155, 6156, 5, 94, 0, 0, 6156,
		6157, 3, 1340, 670, 0, 6157, 6388, 1, 0, 0, 0, 6158, 6159, 5, 138, 0, 0,
		6159, 6160, 5, 63, 0, 0, 6160, 6161, 5, 92, 0, 0, 6161, 6162, 3, 1074,
		537, 0, 6162, 6163, 5, 302, 0, 0, 6163, 6164, 5, 94, 0, 0, 6164, 6165,
		3, 1340, 670, 0, 6165, 6388, 1, 0, 0, 0, 6166, 6167, 5, 138, 0, 0, 6167,
		6168, 5, 63, 0, 0, 6168, 6169, 5, 92, 0, 0, 6169, 6170, 5, 220, 0, 0, 6170,
		6171, 5, 389, 0, 0, 6171, 6172, 3, 1074, 537, 0, 6172, 6173, 5, 302, 0,
		0, 6173, 6174, 5, 94, 0, 0, 6174, 6175, 3, 1340, 670, 0, 6175, 6388, 1,
		0, 0, 0, 6176, 6177, 5, 138, 0, 0, 6177, 6178, 5, 92, 0, 0, 6178, 6179,
		3, 1074, 537, 0, 6179, 6180, 5, 302, 0, 0, 6180, 6181, 3, 724, 362, 0,
		6181, 6182, 3, 1340, 670, 0, 6182, 6183, 5, 94, 0, 0, 6183, 6184, 3, 1340,
		670, 0, 6184, 6388, 1, 0, 0, 0, 6185, 6186, 5, 138, 0, 0, 6186, 6187, 5,
		92, 0, 0, 6187, 6188, 5, 220, 0, 0, 6188, 6189, 5, 389, 0, 0, 6189, 6190,
		3, 1074, 537, 0, 6190, 6191, 5, 302, 0, 0, 6191, 6192, 3, 724, 362, 0,
		6192, 6193, 3, 1340, 670, 0, 6193, 6194, 5, 94, 0, 0, 6194, 6195, 3, 1340,
		670, 0, 6195, 6388, 1, 0, 0, 0, 6196, 6197, 5, 138, 0, 0, 6197, 6198, 5,
		369, 0, 0, 6198, 6199, 3, 1336, 668, 0, 6199, 6200, 5, 302, 0, 0, 6200,
		6201, 3, 724, 362, 0, 6201, 6202, 3, 1340, 670, 0, 6202, 6203, 5, 94, 0,
		0, 6203, 6204, 3, 1340, 670, 0, 6204, 6388, 1, 0, 0, 0, 6205, 6206, 5,
		138, 0, 0, 6206, 6207, 5, 369, 0, 0, 6207, 6208, 5, 220, 0, 0, 6208, 6209,
		5, 389, 0, 0, 6209, 6210, 3, 1336, 668, 0, 6210, 6211, 5, 302, 0, 0, 6211,
		6212, 3, 724, 362, 0, 6212, 6213, 3, 1340, 670, 0, 6213, 6214, 5, 94, 0,
		0, 6214, 6215, 3, 1340, 670, 0, 6215, 6388, 1, 0, 0, 0, 6216, 6217, 5,
		138, 0, 0, 6217, 6218, 5, 251, 0, 0, 6218, 6219, 5, 369, 0, 0, 6219, 6220,
		3, 1336, 668, 0, 6220, 6221, 5, 302, 0, 0, 6221, 6222, 3, 724, 362, 0,
		6222, 6223, 3, 1340, 670, 0, 6223, 6224, 5, 94, 0, 0, 6224, 6225, 3, 1340,
		670, 0, 6225, 6388, 1, 0, 0, 0, 6226, 6227, 5, 138, 0, 0, 6227, 6228, 5,
		251, 0, 0, 6228, 6229, 5, 369, 0, 0, 6229, 6230, 5, 220, 0, 0, 6230, 6231,
		5, 389, 0, 0, 6231, 6232, 3, 1336, 668, 0, 6232, 6233, 5, 302, 0, 0, 6233,
		6234, 3, 724, 362, 0, 6234, 6235, 3, 1340, 670, 0, 6235, 6236, 5, 94, 0,
		0, 6236, 6237, 3, 1340, 670, 0, 6237, 6388, 1, 0, 0, 0, 6238, 6239, 5,
		138, 0, 0, 6239, 6240, 5, 92, 0, 0, 6240, 6241, 3, 1074, 537, 0, 6241,
		6242, 5, 302, 0, 0, 6242, 6243, 5, 45, 0, 0, 6243, 6244, 3, 1340, 670,
		0, 6244, 6245, 5, 94, 0, 0, 6245, 6246, 3, 1340, 670, 0, 6246, 6388, 1,
		0, 0, 0, 6247, 6248, 5, 138, 0, 0, 6248, 6249, 5, 92, 0, 0, 6249, 6250,
		5, 220, 0, 0, 6250, 6251, 5, 389, 0, 0, 6251, 6252, 3, 1074, 537, 0, 6252,
		6253, 5, 302, 0, 0, 6253, 6254, 5, 45, 0, 0, 6254, 6255, 3, 1340, 670,
		0, 6255, 6256, 5, 94, 0, 0, 6256, 6257, 3, 1340, 670, 0, 6257, 6388, 1,
		0, 0, 0, 6258, 6259, 5, 138, 0, 0, 6259, 6260, 5, 63, 0, 0, 6260, 6261,
		5, 92, 0, 0, 6261, 6262, 3, 1074, 537, 0, 6262, 6263, 5, 302, 0, 0, 6263,
		6264, 3, 724, 362, 0, 6264, 6265, 3, 1340, 670, 0, 6265, 6266, 5, 94, 0,
		0, 6266, 6267, 3, 1340, 670, 0, 6267, 6388, 1, 0, 0, 0, 6268, 6269, 5,
		138, 0, 0, 6269, 6270, 5, 63, 0, 0, 6270, 6271, 5, 92, 0, 0, 6271, 6272,
		5, 220, 0, 0, 6272, 6273, 5, 389, 0, 0, 6273, 6274, 3, 1074, 537, 0, 6274,
		6275, 5, 302, 0, 0, 6275, 6276, 3, 724, 362, 0, 6276, 6277, 3, 1340, 670,
		0, 6277, 6278, 5, 94, 0, 0, 6278, 6279, 3, 1340, 670, 0, 6279, 6388, 1,
		0, 0, 0, 6280, 6281, 5, 138, 0, 0, 6281, 6282, 5, 314, 0, 0, 6282, 6283,
		3, 1340, 670, 0, 6283, 6284, 5, 80, 0, 0, 6284, 6285, 3, 1336, 668, 0,
		6285, 6286, 5, 302, 0, 0, 6286, 6287, 5, 94, 0, 0, 6287, 6288, 3, 1340,
		670, 0, 6288, 6388, 1, 0, 0, 0, 6289, 6290, 5, 138, 0, 0, 6290, 6291, 5,
		350, 0, 0, 6291, 6292, 3, 1340, 670, 0, 6292, 6293, 5, 80, 0, 0, 6293,
		6294, 3, 1336, 668, 0, 6294, 6295, 5, 302, 0, 0, 6295, 6296, 5, 94, 0,
		0, 6296, 6297, 3, 1340, 670, 0, 6297, 6388, 1, 0, 0, 0, 6298, 6299, 5,
		138, 0, 0, 6299, 6300, 5, 198, 0, 0, 6300, 6301, 5, 350, 0, 0, 6301, 6302,
		3, 1340, 670, 0, 6302, 6303, 5, 302, 0, 0, 6303, 6304, 5, 94, 0, 0, 6304,
		6305, 3, 1340, 670, 0, 6305, 6388, 1, 0, 0, 0, 6306, 6307, 5, 138, 0, 0,
		6307, 6308, 5, 311, 0, 0, 6308, 6309, 3, 1366, 683, 0, 6309, 6310, 5, 302,
		0, 0, 6310, 6311, 5, 94, 0, 0, 6311, 6312, 3, 1366, 683, 0, 6312, 6388,
		1, 0, 0, 0, 6313, 6314, 5, 138, 0, 0, 6314, 6315, 5, 99, 0, 0, 6315, 6316,
		3, 1366, 683, 0, 6316, 6317, 5, 302, 0, 0, 6317, 6318, 5, 94, 0, 0, 6318,
		6319, 3, 1366, 683, 0, 6319, 6388, 1, 0, 0, 0, 6320, 6321, 5, 138, 0, 0,
		6321, 6322, 5, 344, 0, 0, 6322, 6323, 3, 1340, 670, 0, 6323, 6324, 5, 302,
		0, 0, 6324, 6325, 5, 94, 0, 0, 6325, 6326, 3, 1340, 670, 0, 6326, 6388,
		1, 0, 0, 0, 6327, 6328, 5, 138, 0, 0, 6328, 6329, 5, 335, 0, 0, 6329, 6330,
		3, 524, 262, 0, 6330, 6331, 5, 302, 0, 0, 6331, 6332, 5, 94, 0, 0, 6332,
		6333, 3, 1340, 670, 0, 6333, 6388, 1, 0, 0, 0, 6334, 6335, 5, 138, 0, 0,
		6335, 6336, 5, 348, 0, 0, 6336, 6337, 5, 318, 0, 0, 6337, 6338, 5, 276,
		0, 0, 6338, 6339, 3, 524, 262, 0, 6339, 6340, 5, 302, 0, 0, 6340, 6341,
		5, 94, 0, 0, 6341, 6342, 3, 1340, 670, 0, 6342, 6388, 1, 0, 0, 0, 6343,
		6344, 5, 138, 0, 0, 6344, 6345, 5, 348, 0, 0, 6345, 6346, 5, 318, 0, 0,
		6346, 6347, 5, 185, 0, 0, 6347, 6348, 3, 524, 262, 0, 6348, 6349, 5, 302,
		0, 0, 6349, 6350, 5, 94, 0, 0, 6350, 6351, 3, 1340, 670, 0, 6351, 6388,
		1, 0, 0, 0, 6352, 6353, 5, 138, 0, 0, 6353, 6354, 5, 348, 0, 0, 6354, 6355,
		5, 318, 0, 0, 6355, 6356, 5, 346, 0, 0, 6356, 6357, 3, 524, 262, 0, 6357,
		6358, 5, 302, 0, 0, 6358, 6359, 5, 94, 0, 0, 6359, 6360, 3, 1340, 670,
		0, 6360, 6388, 1, 0, 0, 0, 6361, 6362, 5, 138, 0, 0, 6362, 6363, 5, 348,
		0, 0, 6363, 6364, 5, 318, 0, 0, 6364, 6365, 5, 163, 0, 0, 6365, 6366, 3,
		524, 262, 0, 6366, 6367, 5, 302, 0, 0, 6367, 6368, 5, 94, 0, 0, 6368, 6369,
		3, 1340, 670, 0, 6369, 6388, 1, 0, 0, 0, 6370, 6371, 5, 138, 0, 0, 6371,
		6372, 5, 353, 0, 0, 6372, 6373, 3, 524, 262, 0, 6373, 6374, 5, 302, 0,
		0, 6374, 6375, 5, 94, 0, 0, 6375, 6376, 3, 1340, 670, 0, 6376, 6388, 1,
		0, 0, 0, 6377, 6378, 5, 138, 0, 0, 6378, 6379, 5, 353, 0, 0, 6379, 6380,
		3, 524, 262, 0, 6380, 6381, 5, 302, 0, 0, 6381, 6382, 5, 143, 0, 0, 6382,
		6383, 3, 1340, 670, 0, 6383, 6384, 5, 94, 0, 0, 6384, 6385, 3, 1340, 670,
		0, 6385, 6386, 3, 108, 54, 0, 6386, 6388, 1, 0, 0, 0, 6387, 5919, 1, 0,
		0, 0, 6387, 5926, 1, 0, 0, 0, 6387, 5933, 1, 0, 0, 0, 6387, 5940, 1, 0,
		0, 0, 6387, 5947, 1, 0, 0, 0, 6387, 5954, 1, 0, 0, 0, 6387, 5963, 1, 0,
		0, 0, 6387, 5972, 1, 0, 0, 0, 6387, 5979, 1, 0, 0, 0, 6387, 5986, 1, 0,
		0, 0, 6387, 5994, 1, 0, 0, 0, 6387, 6004, 1, 0, 0, 0, 6387, 6014, 1, 0,
		0, 0, 6387, 6023, 1, 0, 0, 0, 6387, 6034, 1, 0, 0, 0, 6387, 6041, 1, 0,
		0, 0, 6387, 6048, 1, 0, 0, 0, 6387, 6055, 1, 0, 0, 0, 6387, 6062, 1, 0,
		0, 0, 6387, 6069, 1, 0, 0, 0, 6387, 6076, 1, 0, 0, 0, 6387, 6083, 1, 0,
		0, 0, 6387, 6092, 1, 0, 0, 0, 6387, 6099, 1, 0, 0, 0, 6387, 6108, 1, 0,
		0, 0, 6387, 6115, 1, 0, 0, 0, 6387, 6124, 1, 0, 0, 0, 6387, 6132, 1, 0,
		0, 0, 6387, 6142, 1, 0, 0, 0, 6387, 6149, 1, 0, 0, 0, 6387, 6158, 1, 0,
		0, 0, 6387, 6166, 1, 0, 0, 0, 6387, 6176, 1, 0, 0, 0, 6387, 6185, 1, 0,
		0, 0, 6387, 6196, 1, 0, 0, 0, 6387, 6205, 1, 0, 0, 0, 6387, 6216, 1, 0,
		0, 0, 6387, 6226, 1, 0, 0, 0, 6387, 6238, 1, 0, 0, 0, 6387, 6247, 1, 0,
		0, 0, 6387, 6258, 1, 0, 0, 0, 6387, 6268, 1, 0, 0, 0, 6387, 6280, 1, 0,
		0, 0, 6387, 6289, 1, 0, 0, 0, 6387, 6298, 1, 0, 0, 0, 6387, 6306, 1, 0,
		0, 0, 6387, 6313, 1, 0, 0, 0, 6387, 6320, 1, 0, 0, 0, 6387, 6327, 1, 0,
		0, 0, 6387, 6334, 1, 0, 0, 0, 6387, 6343, 1, 0, 0, 0, 6387, 6352, 1, 0,
		0, 0, 6387, 6361, 1, 0, 0, 0, 6387, 6370, 1, 0, 0, 0, 6387, 6377, 1, 0,
		0, 0, 6388, 723, 1, 0, 0, 0, 6389, 6392, 5, 44, 0, 0, 6390, 6392, 1, 0,
		0, 0, 6391, 6389, 1, 0, 0, 0, 6391, 6390, 1, 0, 0, 0, 6392, 725, 1, 0,
		0, 0, 6393, 6394, 5, 326, 0, 0, 6394, 6397, 5, 174, 0, 0, 6395, 6397, 1,
		0, 0, 0, 6396, 6393, 1, 0, 0, 0, 6396, 6395, 1, 0, 0, 0, 6397, 727, 1,
		0, 0, 0, 6398, 6399, 5, 138, 0, 0, 6399, 6400, 5, 211, 0, 0, 6400, 6401,
		3, 626, 313, 0, 6401, 6402, 3, 730, 365, 0, 6402, 6403, 5, 462, 0, 0, 6403,
		6404, 5, 80, 0, 0, 6404, 6405, 5, 204, 0, 0, 6405, 6406, 3, 1340, 670,
		0, 6406, 6456, 1, 0, 0, 0, 6407, 6408, 5, 138, 0, 0, 6408, 6409, 5, 289,
		0, 0, 6409, 6410, 3, 626, 313, 0, 6410, 6411, 3, 730, 365, 0, 6411, 6412,
		5, 462, 0, 0, 6412, 6413, 5, 80, 0, 0, 6413, 6414, 5, 204, 0, 0, 6414,
		6415, 3, 1340, 670, 0, 6415, 6456, 1, 0, 0, 0, 6416, 6417, 5, 138, 0, 0,
		6417, 6418, 5, 442, 0, 0, 6418, 6419, 3, 626, 313, 0, 6419, 6420, 3, 730,
		365, 0, 6420, 6421, 5, 462, 0, 0, 6421, 6422, 5, 80, 0, 0, 6422, 6423,
		5, 204, 0, 0, 6423, 6424, 3, 1340, 670, 0, 6424, 6456, 1, 0, 0, 0, 6425,
		6426, 5, 138, 0, 0, 6426, 6427, 5, 350, 0, 0, 6427, 6428, 3, 1340, 670,
		0, 6428, 6429, 5, 80, 0, 0, 6429, 6430, 3, 1336, 668, 0, 6430, 6431, 3,
		730, 365, 0, 6431, 6432, 5, 462, 0, 0, 6432, 6433, 5, 80, 0, 0, 6433, 6434,
		5, 204, 0, 0, 6434, 6435, 3, 1340, 670, 0, 6435, 6456, 1, 0, 0, 0, 6436,
		6437, 5, 138, 0, 0, 6437, 6438, 5, 251, 0, 0, 6438, 6439, 5, 369, 0, 0,
		6439, 6440, 3, 1336, 668, 0, 6440, 6441, 3, 730, 365, 0, 6441, 6442, 5,
		462, 0, 0, 6442, 6443, 5, 80, 0, 0, 6443, 6444, 5, 204, 0, 0, 6444, 6445,
		3, 1340, 670, 0, 6445, 6456, 1, 0, 0, 0, 6446, 6447, 5, 138, 0, 0, 6447,
		6448, 5, 226, 0, 0, 6448, 6449, 3, 1336, 668, 0, 6449, 6450, 3, 730, 365,
		0, 6450, 6451, 5, 462, 0, 0, 6451, 6452, 5, 80, 0, 0, 6452, 6453, 5, 204,
		0, 0, 6453, 6454, 3, 1340, 670, 0, 6454, 6456, 1, 0, 0, 0, 6455, 6398,
		1, 0, 0, 0, 6455, 6407, 1, 0, 0, 0, 6455, 6416, 1, 0, 0, 0, 6455, 6425,
		1, 0, 0, 0, 6455, 6436, 1, 0, 0, 0, 6455, 6446, 1, 0, 0, 0, 6456, 729,
		1, 0, 0, 0, 6457, 6460, 5, 262, 0, 0, 6458, 6460, 1, 0, 0, 0, 6459, 6457,
		1, 0, 0, 0, 6459, 6458, 1, 0, 0, 0, 6460, 731, 1, 0, 0, 0, 6461, 6462,
		5, 138, 0, 0, 6462, 6463, 5, 136, 0, 0, 6463, 6464, 3, 650, 325, 0, 6464,
		6465, 5, 326, 0, 0, 6465, 6466, 5, 316, 0, 0, 6466, 6467, 3, 1340, 670,
		0, 6467, 6679, 1, 0, 0, 0, 6468, 6469, 5, 138, 0, 0, 6469, 6470, 5, 108,
		0, 0, 6470, 6471, 3, 524, 262, 0, 6471, 6472, 5, 326, 0, 0, 6472, 6473,
		5, 316, 0, 0, 6473, 6474, 3, 1340, 670, 0, 6474, 6679, 1, 0, 0, 0, 6475,
		6476, 5, 138, 0, 0, 6476, 6477, 5, 168, 0, 0, 6477, 6478, 3, 524, 262,
		0, 6478, 6479, 5, 326, 0, 0, 6479, 6480, 5, 316, 0, 0, 6480, 6481, 3, 1340,
		670, 0, 6481, 6679, 1, 0, 0, 0, 6482, 6483, 5, 138, 0, 0, 6483, 6484, 5,
		189, 0, 0, 6484, 6485, 3, 524, 262, 0, 6485, 6486, 5, 326, 0, 0, 6486,
		6487, 5, 316, 0, 0, 6487, 6488, 3, 1340, 670, 0, 6488, 6679, 1, 0, 0, 0,
		6489, 6490, 5, 138, 0, 0, 6490, 6491, 5, 204, 0, 0, 6491, 6492, 3, 1340,
		670, 0, 6492, 6493, 5, 326, 0, 0, 6493, 6494, 5, 316, 0, 0, 6494, 6495,
		3, 1340, 670, 0, 6495, 6679, 1, 0, 0, 0, 6496, 6497, 5, 138, 0, 0, 6497,
		6498, 5, 211, 0, 0, 6498, 6499, 3, 626, 313, 0, 6499, 6500, 5, 326, 0,
		0, 6500, 6501, 5, 316, 0, 0, 6501, 6502, 3, 1340, 670, 0, 6502, 6679, 1,
		0, 0, 0, 6503, 6504, 5, 138, 0, 0, 6504, 6505, 5, 271, 0, 0, 6505, 6506,
		3, 688, 344, 0, 6506, 6507, 5, 326, 0, 0, 6507, 6508, 5, 316, 0, 0, 6508,
		6509, 3, 1340, 670, 0, 6509, 6679, 1, 0, 0, 0, 6510, 6511, 5, 138, 0, 0,
		6511, 6512, 5, 271, 0, 0, 6512, 6513, 5, 156, 0, 0, 6513, 6514, 3, 524,
		262, 0, 6514, 6515, 5, 100, 0, 0, 6515, 6516, 3, 1340, 670, 0, 6516, 6517,
		5, 326, 0, 0, 6517, 6518, 5, 316, 0, 0, 6518, 6519, 3, 1340, 670, 0, 6519,
		6679, 1, 0, 0, 0, 6520, 6521, 5, 138, 0, 0, 6521, 6522, 5, 271, 0, 0, 6522,
		6523, 5, 206, 0, 0, 6523, 6524, 3, 524, 262, 0, 6524, 6525, 5, 100, 0,
		0, 6525, 6526, 3, 1340, 670, 0, 6526, 6527, 5, 326, 0, 0, 6527, 6528, 5,
		316, 0, 0, 6528, 6529, 3, 1340, 670, 0, 6529, 6679, 1, 0, 0, 0, 6530, 6531,
		5, 138, 0, 0, 6531, 6532, 5, 289, 0, 0, 6532, 6533, 3, 626, 313, 0, 6533,
		6534, 5, 326, 0, 0, 6534, 6535, 5, 316, 0, 0, 6535, 6536, 3, 1340, 670,
		0, 6536, 6679, 1, 0, 0, 0, 6537, 6538, 5, 138, 0, 0, 6538, 6539, 5, 442,
		0, 0, 6539, 6540, 3, 626, 313, 0, 6540, 6541, 5, 326, 0, 0, 6541, 6542,
		5, 316, 0, 0, 6542, 6543, 3, 1340, 670, 0, 6543, 6679, 1, 0, 0, 0, 6544,
		6545, 5, 138, 0, 0, 6545, 6546, 5, 92, 0, 0, 6546, 6547, 3, 1074, 537,
		0, 6547, 6548, 5, 326, 0, 0, 6548, 6549, 5, 316, 0, 0, 6549, 6550, 3, 1340,
		670, 0, 6550, 6679, 1, 0, 0, 0, 6551, 6552, 5, 138, 0, 0, 6552, 6553, 5,
		92, 0, 0, 6553, 6554, 5, 220, 0, 0, 6554, 6555, 5, 389, 0, 0, 6555, 6556,
		3, 1074, 537, 0, 6556, 6557, 5, 326, 0, 0, 6557, 6558, 5, 316, 0, 0, 6558,
		6559, 3, 1340, 670, 0, 6559, 6679, 1, 0, 0, 0, 6560, 6561, 5, 138, 0, 0,
		6561, 6562, 5, 335, 0, 0, 6562, 6563, 3, 524, 262, 0, 6563, 6564, 5, 326,
		0, 0, 6564, 6565, 5, 316, 0, 0, 6565, 6566, 3, 1340, 670, 0, 6566, 6679,
		1, 0, 0, 0, 6567, 6568, 5, 138, 0, 0, 6568, 6569, 5, 348, 0, 0, 6569, 6570,
		5, 318, 0, 0, 6570, 6571, 5, 276, 0, 0, 6571, 6572, 3, 524, 262, 0, 6572,
		6573, 5, 326, 0, 0, 6573, 6574, 5, 316, 0, 0, 6574, 6575, 3, 1340, 670,
		0, 6575, 6679, 1, 0, 0, 0, 6576, 6577, 5, 138, 0, 0, 6577, 6578, 5, 348,
		0, 0, 6578, 6579, 5, 318, 0, 0, 6579, 6580, 5, 185, 0, 0, 6580, 6581, 3,
		524, 262, 0, 6581, 6582, 5, 326, 0, 0, 6582, 6583, 5, 316, 0, 0, 6583,
		6584, 3, 1340, 670, 0, 6584, 6679, 1, 0, 0, 0, 6585, 6586, 5, 138, 0, 0,
		6586, 6587, 5, 348, 0, 0, 6587, 6588, 5, 318, 0, 0, 6588, 6589, 5, 346,
		0, 0, 6589, 6590, 3, 524, 262, 0, 6590, 6591, 5, 326, 0, 0, 6591, 6592,
		5, 316, 0, 0, 6592, 6593, 3, 1340, 670, 0, 6593, 6679, 1, 0, 0, 0, 6594,
		6595, 5, 138, 0, 0, 6595, 6596, 5, 348, 0, 0, 6596, 6597, 5, 318, 0, 0,
		6597, 6598, 5, 163, 0, 0, 6598, 6599, 3, 524, 262, 0, 6599, 6600, 5, 326,
		0, 0, 6600, 6601, 5, 316, 0, 0, 6601, 6602, 3, 1340, 670, 0, 6602, 6679,
		1, 0, 0, 0, 6603, 6604, 5, 138, 0, 0, 6604, 6605, 5, 321, 0, 0, 6605, 6606,
		3, 1336, 668, 0, 6606, 6607, 5, 326, 0, 0, 6607, 6608, 5, 316, 0, 0, 6608,
		6609, 3, 1340, 670, 0, 6609, 6679, 1, 0, 0, 0, 6610, 6611, 5, 138, 0, 0,
		6611, 6612, 5, 321, 0, 0, 6612, 6613, 5, 220, 0, 0, 6613, 6614, 5, 389,
		0, 0, 6614, 6615, 3, 1336, 668, 0, 6615, 6616, 5, 326, 0, 0, 6616, 6617,
		5, 316, 0, 0, 6617, 6618, 3, 1340, 670, 0, 6618, 6679, 1, 0, 0, 0, 6619,
		6620, 5, 138, 0, 0, 6620, 6621, 5, 369, 0, 0, 6621, 6622, 3, 1336, 668,
		0, 6622, 6623, 5, 326, 0, 0, 6623, 6624, 5, 316, 0, 0, 6624, 6625, 3, 1340,
		670, 0, 6625, 6679, 1, 0, 0, 0, 6626, 6627, 5, 138, 0, 0, 6627, 6628, 5,
		369, 0, 0, 6628, 6629, 5, 220, 0, 0, 6629, 6630, 5, 389, 0, 0, 6630, 6631,
		3, 1336, 668, 0, 6631, 6632, 5, 326, 0, 0, 6632, 6633, 5, 316, 0, 0, 6633,
		6634, 3, 1340, 670, 0, 6634, 6679, 1, 0, 0, 0, 6635, 6636, 5, 138, 0, 0,
		6636, 6637, 5, 251, 0, 0, 6637, 6638, 5, 369, 0, 0, 6638, 6639, 3, 1336,
		668, 0, 6639, 6640, 5, 326, 0, 0, 6640, 6641, 5, 316, 0, 0, 6641, 6642,
		3, 1340, 670, 0, 6642, 6679, 1, 0, 0, 0, 6643, 6644, 5, 138, 0, 0, 6644,
		6645, 5, 251, 0, 0, 6645, 6646, 5, 369, 0, 0, 6646, 6647, 5, 220, 0, 0,
		6647, 6648, 5, 389, 0, 0, 6648, 6649, 3, 1336, 668, 0, 6649, 6650, 5, 326,
		0, 0, 6650, 6651, 5, 316, 0, 0, 6651, 6652, 3, 1340, 670, 0, 6652, 6679,
		1, 0, 0, 0, 6653, 6654, 5, 138, 0, 0, 6654, 6655, 5, 63, 0, 0, 6655, 6656,
		5, 92, 0, 0, 6656, 6657, 3, 1074, 537, 0, 6657, 6658, 5, 326, 0, 0, 6658,
		6659, 5, 316, 0, 0, 6659, 6660, 3, 1340, 670, 0, 6660, 6679, 1, 0, 0, 0,
		6661, 6662, 5, 138, 0, 0, 6662, 6663, 5, 63, 0, 0, 6663, 6664, 5, 92, 0,
		0, 6664, 6665, 5, 220, 0, 0, 6665, 6666, 5, 389, 0, 0, 6666, 6667, 3, 1074,
		537, 0, 6667, 6668, 5, 326, 0, 0, 6668, 6669, 5, 316, 0, 0, 6669, 6670,
		3, 1340, 670, 0, 6670, 6679, 1, 0, 0, 0, 6671, 6672, 5, 138, 0, 0, 6672,
		6673, 5, 353, 0, 0, 6673, 6674, 3, 524, 262, 0, 6674, 6675, 5, 326, 0,
		0, 6675, 6676, 5, 316, 0, 0, 6676, 6677, 3, 1340, 670, 0, 6677, 6679, 1,
		0, 0, 0, 6678, 6461, 1, 0, 0, 0, 6678, 6468, 1, 0, 0, 0, 6678, 6475, 1,
		0, 0, 0, 6678, 6482, 1, 0, 0, 0, 6678, 6489, 1, 0, 0, 0, 6678, 6496, 1,
		0, 0, 0, 6678, 6503, 1, 0, 0, 0, 6678, 6510, 1, 0, 0, 0, 6678, 6520, 1,
		0, 0, 0, 6678, 6530, 1, 0, 0, 0, 6678, 6537, 1, 0, 0, 0, 6678, 6544, 1,
		0, 0, 0, 6678, 6551, 1, 0, 0, 0, 6678, 6560, 1, 0, 0, 0, 6678, 6567, 1,
		0, 0, 0, 6678, 6576, 1, 0, 0, 0, 6678, 6585, 1, 0, 0, 0, 6678, 6594, 1,
		0, 0, 0, 6678, 6603, 1, 0, 0, 0, 6678, 6610, 1, 0, 0, 0, 6678, 6619, 1,
		0, 0, 0, 6678, 6626, 1, 0, 0, 0, 6678, 6635, 1, 0, 0, 0, 6678, 6643, 1,
		0, 0, 0, 6678, 6653, 1, 0, 0, 0, 6678, 6661, 1, 0, 0, 0, 6678, 6671, 1,
		0, 0, 0, 6679, 733, 1, 0, 0, 0, 6680, 6681, 5, 138, 0, 0, 6681, 6682, 5,
		271, 0, 0, 6682, 6683, 3, 688, 344, 0, 6683, 6684, 5, 326, 0, 0, 6684,
		6685, 5, 2, 0, 0, 6685, 6686, 3, 736, 368, 0, 6686, 6687, 5, 3, 0, 0, 6687,
		735, 1, 0, 0, 0, 6688, 6693, 3, 738, 369, 0, 6689, 6690, 5, 6, 0, 0, 6690,
		6692, 3, 738, 369, 0, 6691, 6689, 1, 0, 0, 0, 6692, 6695, 1, 0, 0, 0, 6693,
		6691, 1, 0, 0, 0, 6693, 6694, 1, 0, 0, 0, 6694, 737, 1, 0, 0, 0, 6695,
		6693, 1, 0, 0, 0, 6696, 6697, 3, 1380, 690, 0, 6697, 6698, 5, 10, 0, 0,
		6698, 6699, 5, 400, 0, 0, 6699, 6705, 1, 0, 0, 0, 6700, 6701, 3, 1380,
		690, 0, 6701, 6702, 5, 10, 0, 0, 6702, 6703, 3, 740, 370, 0, 6703, 6705,
		1, 0, 0, 0, 6704, 6696, 1, 0, 0, 0, 6704, 6700, 1, 0, 0, 0, 6705, 739,
		1, 0, 0, 0, 6706, 6712, 3, 640, 320, 0, 6707, 6712, 3, 1392, 696, 0, 6708,
		6712, 3, 1276, 638, 0, 6709, 6712, 3, 292, 146, 0, 6710, 6712, 3, 1358,
		679, 0, 6711, 6706, 1, 0, 0, 0, 6711, 6707, 1, 0, 0, 0, 6711, 6708, 1,
		0, 0, 0, 6711, 6709, 1, 0, 0, 0, 6711, 6710, 1, 0, 0, 0, 6712, 741, 1,
		0, 0, 0, 6713, 6714, 5, 138, 0, 0, 6714, 6715, 5, 353, 0, 0, 6715, 6716,
		3, 524, 262, 0, 6716, 6717, 5, 326, 0, 0, 6717, 6718, 5, 2, 0, 0, 6718,
		6719, 3, 736, 368, 0, 6719, 6720, 5, 3, 0, 0, 6720, 743, 1, 0, 0, 0, 6721,
		6722, 5, 138, 0, 0, 6722, 6723, 5, 136, 0, 0, 6723, 6724, 3, 650, 325,
		0, 6724, 6725, 5, 275, 0, 0, 6725, 6726, 5, 94, 0, 0, 6726, 6727, 3, 1368,
		684, 0, 6727, 6905, 1, 0, 0, 0, 6728, 6729, 5, 138, 0, 0, 6729, 6730, 5,
		108, 0, 0, 6730, 6731, 3, 524, 262, 0, 6731, 6732, 5, 275, 0, 0, 6732,
		6733, 5, 94, 0, 0, 6733, 6734, 3, 1368, 684, 0, 6734, 6905, 1, 0, 0, 0,
		6735, 6736, 5, 138, 0, 0, 6736, 6737, 5, 168, 0, 0, 6737, 6738, 3, 524,
		262, 0, 6738, 6739, 5, 275, 0, 0, 6739, 6740, 5, 94, 0, 0, 6740, 6741,
		3, 1368, 684, 0, 6741, 6905, 1, 0, 0, 0, 6742, 6743, 5, 138, 0, 0, 6743,
		6744, 5, 175, 0, 0, 6744, 6745, 3, 1340, 670, 0, 6745, 6746, 5, 275, 0,
		0, 6746, 6747, 5, 94, 0, 0, 6747, 6748, 3, 1368, 684, 0, 6748, 6905, 1,
		0, 0, 0, 6749, 6750, 5, 138, 0, 0, 6750, 6751, 5, 189, 0, 0, 6751, 6752,
		3, 524, 262, 0, 6752, 6753, 5, 275, 0, 0, 6753, 6754, 5, 94, 0, 0, 6754,
		6755, 3, 1368, 684, 0, 6755, 6905, 1, 0, 0, 0, 6756, 6757, 5, 138, 0, 0,
		6757, 6758, 5, 211, 0, 0, 6758, 6759, 3, 626, 313, 0, 6759, 6760, 5, 275,
		0, 0, 6760, 6761, 5, 94, 0, 0, 6761, 6762, 3, 1368, 684, 0, 6762, 6905,
		1, 0, 0, 0, 6763, 6764, 5, 138, 0, 0, 6764, 6765, 3, 308, 154, 0, 6765,
		6766, 5, 238, 0, 0, 6766, 6767, 3, 1340, 670, 0, 6767, 6768, 5, 275, 0,
		0, 6768, 6769, 5, 94, 0, 0, 6769, 6770, 3, 1368, 684, 0, 6770, 6905, 1,
		0, 0, 0, 6771, 6772, 5, 138, 0, 0, 6772, 6773, 5, 239, 0, 0, 6773, 6774,
		5, 267, 0, 0, 6774, 6775, 3, 292, 146, 0, 6775, 6776, 5, 275, 0, 0, 6776,
		6777, 5, 94, 0, 0, 6777, 6778, 3, 1368, 684, 0, 6778, 6905, 1, 0, 0, 0,
		6779, 6780, 5, 138, 0, 0, 6780, 6781, 5, 271, 0, 0, 6781, 6782, 3, 688,
		344, 0, 6782, 6783, 5, 275, 0, 0, 6783, 6784, 5, 94, 0, 0, 6784, 6785,
		3, 1368, 684, 0, 6785, 6905, 1, 0, 0, 0, 6786, 6787, 5, 138, 0, 0, 6787,
		6788, 5, 271, 0, 0, 6788, 6789, 5, 156, 0, 0, 6789, 6790, 3, 524, 262,
		0, 6790, 6791, 5, 100, 0, 0, 6791, 6792, 3, 1340, 670, 0, 6792, 6793, 5,
		275, 0, 0, 6793, 6794, 5, 94, 0, 0, 6794, 6795, 3, 1368, 684, 0, 6795,
		6905, 1, 0, 0, 0, 6796, 6797, 5, 138, 0, 0, 6797, 6798, 5, 271, 0, 0, 6798,
		6799, 5, 206, 0, 0, 6799, 6800, 3, 524, 262, 0, 6800, 6801, 5, 100, 0,
		0, 6801, 6802, 3, 1340, 670, 0, 6802, 6803, 5, 275, 0, 0, 6803, 6804, 5,
		94, 0, 0, 6804, 6805, 3, 1368, 684, 0, 6805, 6905, 1, 0, 0, 0, 6806, 6807,
		5, 138, 0, 0, 6807, 6808, 5, 289, 0, 0, 6808, 6809, 3, 626, 313, 0, 6809,
		6810, 5, 275, 0, 0, 6810, 6811, 5, 94, 0, 0, 6811, 6812, 3, 1368, 684,
		0, 6812, 6905, 1, 0, 0, 0, 6813, 6814, 5, 138, 0, 0, 6814, 6815, 5, 442,
		0, 0, 6815, 6816, 3, 626, 313, 0, 6816, 6817, 5, 275, 0, 0, 6817, 6818,
		5, 94, 0, 0, 6818, 6819, 3, 1368, 684, 0, 6819, 6905, 1, 0, 0, 0, 6820,
		6821, 5, 138, 0, 0, 6821, 6822, 5, 316, 0, 0, 6822, 6823, 3, 1340, 670,
		0, 6823, 6824, 5, 275, 0, 0, 6824, 6825, 5, 94, 0, 0, 6825, 6826, 3, 1368,
		684, 0, 6826, 6905, 1, 0, 0, 0, 6827, 6828, 5, 138, 0, 0, 6828, 6829, 5,
		353, 0, 0, 6829, 6830, 3, 524, 262, 0, 6830, 6831, 5, 275, 0, 0, 6831,
		6832, 5, 94, 0, 0, 6832, 6833, 3, 1368, 684, 0, 6833, 6905, 1, 0, 0, 0,
		6834, 6835, 5, 138, 0, 0, 6835, 6836, 5, 344, 0, 0, 6836, 6837, 3, 1340,
		670, 0, 6837, 6838, 5, 275, 0, 0, 6838, 6839, 5, 94, 0, 0, 6839, 6840,
		3, 1368, 684, 0, 6840, 6905, 1, 0, 0, 0, 6841, 6842, 5, 138, 0, 0, 6842,
		6843, 5, 335, 0, 0, 6843, 6844, 3, 524, 262, 0, 6844, 6845, 5, 275, 0,
		0, 6845, 6846, 5, 94, 0, 0, 6846, 6847, 3, 1368, 684, 0, 6847, 6905, 1,
		0, 0, 0, 6848, 6849, 5, 138, 0, 0, 6849, 6850, 5, 348, 0, 0, 6850, 6851,
		5, 318, 0, 0, 6851, 6852, 5, 185, 0, 0, 6852, 6853, 3, 524, 262, 0, 6853,
		6854, 5, 275, 0, 0, 6854, 6855, 5, 94, 0, 0, 6855, 6856, 3, 1368, 684,
		0, 6856, 6905, 1, 0, 0, 0, 6857, 6858, 5, 138, 0, 0, 6858, 6859, 5, 348,
		0, 0, 6859, 6860, 5, 318, 0, 0, 6860, 6861, 5, 163, 0, 0, 6861, 6862, 3,
		524, 262, 0, 6862, 6863, 5, 275, 0, 0, 6863, 6864, 5, 94, 0, 0, 6864, 6865,
		3, 1368, 684, 0, 6865, 6905, 1, 0, 0, 0, 6866, 6867, 5, 138, 0, 0, 6867,
		6868, 5, 63, 0, 0, 6868, 6869, 5, 174, 0, 0, 6869, 6870, 5, 374, 0, 0,
		6870, 6871, 3, 1340, 670, 0, 6871, 6872, 5, 275, 0, 0, 6872, 6873, 5, 94,
		0, 0, 6873, 6874, 3, 1368, 684, 0, 6874, 6905, 1, 0, 0, 0, 6875, 6876,
		5, 138, 0, 0, 6876, 6877, 5, 324, 0, 0, 6877, 6878, 3, 1340, 670, 0, 6878,
		6879, 5, 275, 0, 0, 6879, 6880, 5, 94, 0, 0, 6880, 6881, 3, 1368, 684,
		0, 6881, 6905, 1, 0, 0, 0, 6882, 6883, 5, 138, 0, 0, 6883, 6884, 5, 198,
		0, 0, 6884, 6885, 5, 350, 0, 0, 6885, 6886, 3, 1340, 670, 0, 6886, 6887,
		5, 275, 0, 0, 6887, 6888, 5, 94, 0, 0, 6888, 6889, 3, 1368, 684, 0, 6889,
		6905, 1, 0, 0, 0, 6890, 6891, 5, 138, 0, 0, 6891, 6892, 5, 452, 0, 0, 6892,
		6893, 3, 1340, 670, 0, 6893, 6894, 5, 275, 0, 0, 6894, 6895, 5, 94, 0,
		0, 6895, 6896, 3, 1368, 684, 0, 6896, 6905, 1, 0, 0, 0, 6897, 6898, 5,
		138, 0, 0, 6898, 6899, 5, 451, 0, 0, 6899, 6900, 3, 1340, 670, 0, 6900,
		6901, 5, 275, 0, 0, 6901, 6902, 5, 94, 0, 0, 6902, 6903, 3, 1368, 684,
		0, 6903, 6905, 1, 0, 0, 0, 6904, 6721, 1, 0, 0, 0, 6904, 6728, 1, 0, 0,
		0, 6904, 6735, 1, 0, 0, 0, 6904, 6742, 1, 0, 0, 0, 6904, 6749, 1, 0, 0,
		0, 6904, 6756, 1, 0, 0, 0, 6904, 6763, 1, 0, 0, 0, 6904, 6771, 1, 0, 0,
		0, 6904, 6779, 1, 0, 0, 0, 6904, 6786, 1, 0, 0, 0, 6904, 6796, 1, 0, 0,
		0, 6904, 6806, 1, 0, 0, 0, 6904, 6813, 1, 0, 0, 0, 6904, 6820, 1, 0, 0,
		0, 6904, 6827, 1, 0, 0, 0, 6904, 6834, 1, 0, 0, 0, 6904, 6841, 1, 0, 0,
		0, 6904, 6848, 1, 0, 0, 0, 6904, 6857, 1, 0, 0, 0, 6904, 6866, 1, 0, 0,
		0, 6904, 6875, 1, 0, 0, 0, 6904, 6882, 1, 0, 0, 0, 6904, 6890, 1, 0, 0,
		0, 6904, 6897, 1, 0, 0, 0, 6905, 745, 1, 0, 0, 0, 6906, 6907, 5, 46, 0,
		0, 6907, 6908, 5, 452, 0, 0, 6908, 6909, 3, 1340, 670, 0, 6909, 6910, 3,
		748, 374, 0, 6910, 6911, 3, 664, 332, 0, 6911, 747, 1, 0, 0, 0, 6912, 6915,
		3, 750, 375, 0, 6913, 6915, 1, 0, 0, 0, 6914, 6912, 1, 0, 0, 0, 6914, 6913,
		1, 0, 0, 0, 6915, 749, 1, 0, 0, 0, 6916, 6917, 5, 62, 0, 0, 6917, 6918,
		5, 92, 0, 0, 6918, 6923, 3, 1076, 538, 0, 6919, 6920, 5, 62, 0, 0, 6920,
		6921, 5, 30, 0, 0, 6921, 6923, 5, 343, 0, 0, 6922, 6916, 1, 0, 0, 0, 6922,
		6919, 1, 0, 0, 0, 6923, 751, 1, 0, 0, 0, 6924, 6925, 5, 138, 0, 0, 6925,
		6926, 5, 452, 0, 0, 6926, 6927, 3, 1340, 670, 0, 6927, 6928, 5, 326, 0,
		0, 6928, 6929, 3, 460, 230, 0, 6929, 6952, 1, 0, 0, 0, 6930, 6931, 5, 138,
		0, 0, 6931, 6932, 5, 452, 0, 0, 6932, 6933, 3, 1340, 670, 0, 6933, 6934,
		5, 133, 0, 0, 6934, 6935, 5, 92, 0, 0, 6935, 6936, 3, 1076, 538, 0, 6936,
		6952, 1, 0, 0, 0, 6937, 6938, 5, 138, 0, 0, 6938, 6939, 5, 452, 0, 0, 6939,
		6940, 3, 1340, 670, 0, 6940, 6941, 5, 326, 0, 0, 6941, 6942, 5, 92, 0,
		0, 6942, 6943, 3, 1076, 538, 0, 6943, 6952, 1, 0, 0, 0, 6944, 6945, 5,
		138, 0, 0, 6945, 6946, 5, 452, 0, 0, 6946, 6947, 3, 1340, 670, 0, 6947,
		6948, 5, 191, 0, 0, 6948, 6949, 5, 92, 0, 0, 6949, 6950, 3, 1076, 538,
		0, 6950, 6952, 1, 0, 0, 0, 6951, 6924, 1, 0, 0, 0, 6951, 6930, 1, 0, 0,
		0, 6951, 6937, 1, 0, 0, 0, 6951, 6944, 1, 0, 0, 0, 6952, 753, 1, 0, 0,
		0, 6953, 6954, 5, 46, 0, 0, 6954, 6955, 5, 451, 0, 0, 6955, 6956, 3, 1340,
		670, 0, 6956, 6957, 5, 164, 0, 0, 6957, 6958, 3, 1358, 679, 0, 6958, 6959,
		5, 452, 0, 0, 6959, 6960, 3, 756, 378, 0, 6960, 6961, 3, 664, 332, 0, 6961,
		755, 1, 0, 0, 0, 6962, 6967, 3, 758, 379, 0, 6963, 6964, 5, 6, 0, 0, 6964,
		6966, 3, 758, 379, 0, 6965, 6963, 1, 0, 0, 0, 6966, 6969, 1, 0, 0, 0, 6967,
		6965, 1, 0, 0, 0, 6967, 6968, 1, 0, 0, 0, 6968, 757, 1, 0, 0, 0, 6969,
		6967, 1, 0, 0, 0, 6970, 6971, 3, 1380, 690, 0, 6971, 759, 1, 0, 0, 0, 6972,
		6973, 5, 138, 0, 0, 6973, 6974, 5, 451, 0, 0, 6974, 6975, 3, 1340, 670,
		0, 6975, 6976, 5, 326, 0, 0, 6976, 6977, 3, 460, 230, 0, 6977, 7010, 1,
		0, 0, 0, 6978, 6979, 5, 138, 0, 0, 6979, 6980, 5, 451, 0, 0, 6980, 6981,
		3, 1340, 670, 0, 6981, 6982, 5, 164, 0, 0, 6982, 6983, 3, 1358, 679, 0,
		6983, 7010, 1, 0, 0, 0, 6984, 6985, 5, 138, 0, 0, 6985, 6986, 5, 451, 0,
		0, 6986, 6987, 3, 1340, 670, 0, 6987, 6988, 5, 298, 0, 0, 6988, 6989, 5,
		452, 0, 0, 6989, 6990, 3, 664, 332, 0, 6990, 7010, 1, 0, 0, 0, 6991, 6992,
		5, 138, 0, 0, 6992, 6993, 5, 451, 0, 0, 6993, 6994, 3, 1340, 670, 0, 6994,
		6995, 5, 326, 0, 0, 6995, 6996, 5, 452, 0, 0, 6996, 6997, 3, 756, 378,
		0, 6997, 6998, 3, 664, 332, 0, 6998, 7010, 1, 0, 0, 0, 6999, 7000, 5, 138,
		0, 0, 7000, 7001, 5, 451, 0, 0, 7001, 7002, 3, 1340, 670, 0, 7002, 7003,
		5, 193, 0, 0, 7003, 7010, 1, 0, 0, 0, 7004, 7005, 5, 138, 0, 0, 7005, 7006,
		5, 451, 0, 0, 7006, 7007, 3, 1340, 670, 0, 7007, 7008, 5, 186, 0, 0, 7008,
		7010, 1, 0, 0, 0, 7009, 6972, 1, 0, 0, 0, 7009, 6978, 1, 0, 0, 0, 7009,
		6984, 1, 0, 0, 0, 7009, 6991, 1, 0, 0, 0, 7009, 6999, 1, 0, 0, 0, 7009,
		7004, 1, 0, 0, 0, 7010, 761, 1, 0, 0, 0, 7011, 7012, 5, 191, 0, 0, 7012,
		7013, 5, 451, 0, 0, 7013, 7014, 3, 1340, 670, 0, 7014, 7015, 3, 108, 54,
		0, 7015, 7024, 1, 0, 0, 0, 7016, 7017, 5, 191, 0, 0, 7017, 7018, 5, 451,
		0, 0, 7018, 7019, 5, 220, 0, 0, 7019, 7020, 5, 389, 0, 0, 7020, 7021, 3,
		1340, 670, 0, 7021, 7022, 3, 108, 54, 0, 7022, 7024, 1, 0, 0, 0, 7023,
		7011, 1, 0, 0, 0, 7023, 7016, 1, 0, 0, 0, 7024, 763, 1, 0, 0, 0, 7025,
		7026, 5, 46, 0, 0, 7026, 7027, 3, 618, 309, 0, 7027, 7028, 5, 314, 0, 0,
		7028, 7029, 3, 1340, 670, 0, 7029, 7030, 5, 36, 0, 0, 7030, 7031, 5, 80,
		0, 0, 7031, 7032, 3, 774, 387, 0, 7032, 7033, 5, 94, 0, 0, 7033, 7034,
		3, 1336, 668, 0, 7034, 7035, 3, 1094, 547, 0, 7035, 7036, 5, 57, 0, 0,
		7036, 7037, 3, 776, 388, 0, 7037, 7038, 3, 766, 383, 0, 7038, 765, 1, 0,
		0, 0, 7039, 7046, 5, 263, 0, 0, 7040, 7046, 3, 770, 385, 0, 7041, 7042,
		5, 2, 0, 0, 7042, 7043, 3, 768, 384, 0, 7043, 7044, 5, 3, 0, 0, 7044, 7046,
		1, 0, 0, 0, 7045, 7039, 1, 0, 0, 0, 7045, 7040, 1, 0, 0, 0, 7045, 7041,
		1, 0, 0, 0, 7046, 767, 1, 0, 0, 0, 7047, 7052, 3, 772, 386, 0, 7048, 7049,
		5, 7, 0, 0, 7049, 7051, 3, 772, 386, 0, 7050, 7048, 1, 0, 0, 0, 7051, 7054,
		1, 0, 0, 0, 7052, 7050, 1, 0, 0, 0, 7052, 7053, 1, 0, 0, 0, 7053, 769,
		1, 0, 0, 0, 7054, 7052, 1, 0, 0, 0, 7055, 7061, 3, 960, 480, 0, 7056, 7061,
		3, 902, 451, 0, 7057, 7061, 3, 942, 471, 0, 7058, 7061, 3, 928, 464, 0,
		7059, 7061, 3, 778, 389, 0, 7060, 7055, 1, 0, 0, 0, 7060, 7056, 1, 0, 0,
		0, 7060, 7057, 1, 0, 0, 0, 7060, 7058, 1, 0, 0, 0, 7060, 7059, 1, 0, 0,
		0, 7061, 771, 1, 0, 0, 0, 7062, 7065, 3, 770, 385, 0, 7063, 7065, 1, 0,
		0, 0, 7064, 7062, 1, 0, 0, 0, 7064, 7063, 1, 0, 0, 0, 7065, 773, 1, 0,
		0, 0, 7066, 7067, 7, 31, 0, 0, 7067, 775, 1, 0, 0, 0, 7068, 7072, 5, 233,
		0, 0, 7069, 7072, 5, 137, 0, 0, 7070, 7072, 1, 0, 0, 0, 7071, 7068, 1,
		0, 0, 0, 7071, 7069, 1, 0, 0, 0, 7071, 7070, 1, 0, 0, 0, 7072, 777, 1,
		0, 0, 0, 7073, 7074, 5, 264, 0, 0, 7074, 7075, 3, 1372, 686, 0, 7075, 7076,
		3, 780, 390, 0, 7076, 779, 1, 0, 0, 0, 7077, 7078, 5, 6, 0, 0, 7078, 7081,
		3, 1358, 679, 0, 7079, 7081, 1, 0, 0, 0, 7080, 7077, 1, 0, 0, 0, 7080,
		7079, 1, 0, 0, 0, 7081, 781, 1, 0, 0, 0, 7082, 7083, 5, 243, 0, 0, 7083,
		7084, 3, 1372, 686, 0, 7084, 783, 1, 0, 0, 0, 7085, 7086, 5, 359, 0, 0,
		7086, 7090, 3, 1372, 686, 0, 7087, 7088, 5, 359, 0, 0, 7088, 7090, 5, 9,
		0, 0, 7089, 7085, 1, 0, 0, 0, 7089, 7087, 1, 0, 0, 0, 7090, 785, 1, 0,
		0, 0, 7091, 7092, 5, 129, 0, 0, 7092, 7093, 3, 788, 394, 0, 7093, 7094,
		3, 796, 398, 0, 7094, 7142, 1, 0, 0, 0, 7095, 7096, 5, 146, 0, 0, 7096,
		7097, 3, 788, 394, 0, 7097, 7098, 3, 794, 397, 0, 7098, 7142, 1, 0, 0,
		0, 7099, 7100, 5, 333, 0, 0, 7100, 7101, 5, 349, 0, 0, 7101, 7142, 3, 794,
		397, 0, 7102, 7103, 5, 161, 0, 0, 7103, 7104, 3, 788, 394, 0, 7104, 7105,
		3, 796, 398, 0, 7105, 7142, 1, 0, 0, 0, 7106, 7107, 5, 454, 0, 0, 7107,
		7108, 3, 788, 394, 0, 7108, 7109, 3, 796, 398, 0, 7109, 7142, 1, 0, 0,
		0, 7110, 7111, 5, 312, 0, 0, 7111, 7112, 3, 788, 394, 0, 7112, 7113, 3,
		796, 398, 0, 7113, 7142, 1, 0, 0, 0, 7114, 7115, 5, 315, 0, 0, 7115, 7142,
		3, 1372, 686, 0, 7116, 7117, 5, 301, 0, 0, 7117, 7118, 5, 315, 0, 0, 7118,
		7142, 3, 1372, 686, 0, 7119, 7120, 5, 301, 0, 0, 7120, 7142, 3, 1372, 686,
		0, 7121, 7122, 5, 312, 0, 0, 7122, 7123, 3, 788, 394, 0, 7123, 7124, 5,
		94, 0, 0, 7124, 7125, 5, 315, 0, 0, 7125, 7126, 3, 1372, 686, 0, 7126,
		7142, 1, 0, 0, 0, 7127, 7128, 5, 312, 0, 0, 7128, 7129, 3, 788, 394, 0,
		7129, 7130, 5, 94, 0, 0, 7130, 7131, 3, 1372, 686, 0, 7131, 7142, 1, 0,
		0, 0, 7132, 7133, 5, 283, 0, 0, 7133, 7134, 5, 349, 0, 0, 7134, 7142, 3,
		1358, 679, 0, 7135, 7136, 5, 161, 0, 0, 7136, 7137, 5, 284, 0, 0, 7137,
		7142, 3, 1358, 679, 0, 7138, 7139, 5, 312, 0, 0, 7139, 7140, 5, 284, 0,
		0, 7140, 7142, 3, 1358, 679, 0, 7141, 7091, 1, 0, 0, 0, 7141, 7095, 1,
		0, 0, 0, 7141, 7099, 1, 0, 0, 0, 7141, 7102, 1, 0, 0, 0, 7141, 7106, 1,
		0, 0, 0, 7141, 7110, 1, 0, 0, 0, 7141, 7114, 1, 0, 0, 0, 7141, 7116, 1,
		0, 0, 0, 7141, 7119, 1, 0, 0, 0, 7141, 7121, 1, 0, 0, 0, 7141, 7127, 1,
		0, 0, 0, 7141, 7132, 1, 0, 0, 0, 7141, 7135, 1, 0, 0, 0, 7141, 7138, 1,
		0, 0, 0, 7142, 787, 1, 0, 0, 0, 7143, 7147, 5, 373, 0, 0, 7144, 7147, 5,
		349, 0, 0, 7145, 7147, 1, 0, 0, 0, 7146, 7143, 1, 0, 0, 0, 7146, 7144,
		1, 0, 0, 0, 7146, 7145, 1, 0, 0, 0, 7147, 789, 1, 0, 0, 0, 7148, 7149,
		5, 235, 0, 0, 7149, 7150, 5, 242, 0, 0, 7150, 7159, 3, 64, 32, 0, 7151,
		7152, 5, 293, 0, 0, 7152, 7159, 5, 81, 0, 0, 7153, 7154, 5, 293, 0, 0,
		7154, 7159, 5, 375, 0, 0, 7155, 7159, 5, 54, 0, 0, 7156, 7157, 5, 77, 0,
		0, 7157, 7159, 5, 54, 0, 0, 7158, 7148, 1, 0, 0, 0, 7158, 7151, 1, 0, 0,
		0, 7158, 7153, 1, 0, 0, 0, 7158, 7155, 1, 0, 0, 0, 7158, 7156, 1, 0, 0,
		0, 7159, 791, 1, 0, 0, 0, 7160, 7167, 3, 790, 395, 0, 7161, 7163, 5, 6,
		0, 0, 7162, 7161, 1, 0, 0, 0, 7162, 7163, 1, 0, 0, 0, 7163, 7164, 1, 0,
		0, 0, 7164, 7166, 3, 790, 395, 0, 7165, 7162, 1, 0, 0, 0, 7166, 7169, 1,
		0, 0, 0, 7167, 7165, 1, 0, 0, 0, 7167, 7168, 1, 0, 0, 0, 7168, 793, 1,
		0, 0, 0, 7169, 7167, 1, 0, 0, 0, 7170, 7173, 3, 792, 396, 0, 7171, 7173,
		1, 0, 0, 0, 7172, 7170, 1, 0, 0, 0, 7172, 7171, 1, 0, 0, 0, 7173, 795,
		1, 0, 0, 0, 7174, 7176, 5, 33, 0, 0, 7175, 7177, 5, 262, 0, 0, 7176, 7175,
		1, 0, 0, 0, 7176, 7177, 1, 0, 0, 0, 7177, 7178, 1, 0, 0, 0, 7178, 7181,
		5, 153, 0, 0, 7179, 7181, 1, 0, 0, 0, 7180, 7174, 1, 0, 0, 0, 7180, 7179,
		1, 0, 0, 0, 7181, 797, 1, 0, 0, 0, 7182, 7185, 5, 46, 0, 0, 7183, 7184,
		5, 82, 0, 0, 7184, 7186, 5, 304, 0, 0, 7185, 7183, 1, 0, 0, 0, 7185, 7186,
		1, 0, 0, 0, 7186, 7187, 1, 0, 0, 0, 7187, 7201, 3, 174, 87, 0, 7188, 7189,
		5, 369, 0, 0, 7189, 7190, 3, 1336, 668, 0, 7190, 7191, 3, 214, 107, 0,
		7191, 7192, 3, 118, 59, 0, 7192, 7202, 1, 0, 0, 0, 7193, 7194, 5, 296,
		0, 0, 7194, 7195, 5, 369, 0, 0, 7195, 7196, 3, 1336, 668, 0, 7196, 7197,
		5, 2, 0, 0, 7197, 7198, 3, 216, 108, 0, 7198, 7199, 5, 3, 0, 0, 7199, 7200,
		3, 118, 59, 0, 7200, 7202, 1, 0, 0, 0, 7201, 7188, 1, 0, 0, 0, 7201, 7193,
		1, 0, 0, 0, 7202, 7203, 1, 0, 0, 0, 7203, 7204, 5, 36, 0, 0, 7204, 7205,
		3, 960, 480, 0, 7205, 7206, 3, 800, 400, 0, 7206, 799, 1, 0, 0, 0, 7207,
		7209, 5, 105, 0, 0, 7208, 7210, 7, 32, 0, 0, 7209, 7208, 1, 0, 0, 0, 7209,
		7210, 1, 0, 0, 0, 7210, 7211, 1, 0, 0, 0, 7211, 7212, 5, 42, 0, 0, 7212,
		7215, 5, 272, 0, 0, 7213, 7215, 1, 0, 0, 0, 7214, 7207, 1, 0, 0, 0, 7214,
		7213, 1, 0, 0, 0, 7215, 801, 1, 0, 0, 0, 7216, 7217, 5, 244, 0, 0, 7217,
		7218, 3, 1344, 672, 0, 7218, 803, 1, 0, 0, 0, 7219, 7220, 5, 46, 0, 0,
		7220, 7221, 5, 175, 0, 0, 7221, 7222, 3, 1340, 670, 0, 7222, 7223, 3, 16,
		8, 0, 7223, 7224, 3, 806, 403, 0, 7224, 805, 1, 0, 0, 0, 7225, 7228, 3,
		808, 404, 0, 7226, 7228, 1, 0, 0, 0, 7227, 7225, 1, 0, 0, 0, 7227, 7226,
		1, 0, 0, 0, 7228, 807, 1, 0, 0, 0, 7229, 7231, 3, 810, 405, 0, 7230, 7229,
		1, 0, 0, 0, 7231, 7232, 1, 0, 0, 0, 7232, 7230, 1, 0, 0, 0, 7232, 7233,
		1, 0, 0, 0, 7233, 809, 1, 0, 0, 0, 7234, 7235, 3, 812, 406, 0, 7235, 7239,
		3, 814, 407, 0, 7236, 7240, 3, 1364, 682, 0, 7237, 7240, 3, 66, 33, 0,
		7238, 7240, 5, 53, 0, 0, 7239, 7236, 1, 0, 0, 0, 7239, 7237, 1, 0, 0, 0,
		7239, 7238, 1, 0, 0, 0, 7240, 811, 1, 0, 0, 0, 7241, 7250, 3, 1382, 691,
		0, 7242, 7243, 5, 164, 0, 0, 7243, 7250, 5, 74, 0, 0, 7244, 7250, 5, 194,
		0, 0, 7245, 7250, 5, 246, 0, 0, 7246, 7250, 5, 275, 0, 0, 7247, 7250, 5,
		344, 0, 0, 7248, 7250, 5, 346, 0, 0, 7249, 7241, 1, 0, 0, 0, 7249, 7242,
		1, 0, 0, 0, 7249, 7244, 1, 0, 0, 0, 7249, 7245, 1, 0, 0, 0, 7249, 7246,
		1, 0, 0, 0, 7249, 7247, 1, 0, 0, 0, 7249, 7248, 1, 0, 0, 0, 7250, 813,
		1, 0, 0, 0, 7251, 7254, 5, 10, 0, 0, 7252, 7254, 1, 0, 0, 0, 7253, 7251,
		1, 0, 0, 0, 7253, 7252, 1, 0, 0, 0, 7254, 815, 1, 0, 0, 0, 7255, 7256,
		5, 138, 0, 0, 7256, 7257, 5, 175, 0, 0, 7257, 7264, 3, 1340, 670, 0, 7258,
		7259, 5, 105, 0, 0, 7259, 7265, 3, 806, 403, 0, 7260, 7265, 3, 806, 403,
		0, 7261, 7262, 5, 326, 0, 0, 7262, 7263, 5, 344, 0, 0, 7263, 7265, 3, 1340,
		670, 0, 7264, 7258, 1, 0, 0, 0, 7264, 7260, 1, 0, 0, 0, 7264, 7261, 1,
		0, 0, 0, 7265, 817, 1, 0, 0, 0, 7266, 7267, 5, 138, 0, 0, 7267, 7268, 5,
		175, 0, 0, 7268, 7269, 3, 1340, 670, 0, 7269, 7270, 3, 80, 40, 0, 7270,
		819, 1, 0, 0, 0, 7271, 7272, 5, 191, 0, 0, 7272, 7275, 5, 175, 0, 0, 7273,
		7274, 5, 220, 0, 0, 7274, 7276, 5, 389, 0, 0, 7275, 7273, 1, 0, 0, 0, 7275,
		7276, 1, 0, 0, 0, 7276, 7277, 1, 0, 0, 0, 7277, 7283, 3, 1340, 670, 0,
		7278, 7279, 3, 16, 8, 0, 7279, 7280, 5, 2, 0, 0, 7280, 7281, 3, 822, 411,
		0, 7281, 7282, 5, 3, 0, 0, 7282, 7284, 1, 0, 0, 0, 7283, 7278, 1, 0, 0,
		0, 7283, 7284, 1, 0, 0, 0, 7284, 821, 1, 0, 0, 0, 7285, 7290, 3, 824, 412,
		0, 7286, 7287, 5, 6, 0, 0, 7287, 7289, 3, 824, 412, 0, 7288, 7286, 1, 0,
		0, 0, 7289, 7292, 1, 0, 0, 0, 7290, 7288, 1, 0, 0, 0, 7290, 7291, 1, 0,
		0, 0, 7291, 823, 1, 0, 0, 0, 7292, 7290, 1, 0, 0, 0, 7293, 7294, 5, 209,
		0, 0, 7294, 825, 1, 0, 0, 0, 7295, 7296, 5, 138, 0, 0, 7296, 7297, 5, 108,
		0, 0, 7297, 7298, 3, 524, 262, 0, 7298, 7299, 5, 298, 0, 0, 7299, 7300,
		5, 368, 0, 0, 7300, 827, 1, 0, 0, 0, 7301, 7302, 5, 138, 0, 0, 7302, 7303,
		5, 342, 0, 0, 7303, 7304, 7, 33, 0, 0, 7304, 7305, 3, 54, 27, 0, 7305,
		829, 1, 0, 0, 0, 7306, 7307, 5, 46, 0, 0, 7307, 7308, 5, 189, 0, 0, 7308,
		7309, 3, 524, 262, 0, 7309, 7310, 3, 834, 417, 0, 7310, 7311, 3, 1118,
		559, 0, 7311, 7312, 3, 192, 96, 0, 7312, 831, 1, 0, 0, 0, 7313, 7314, 5,
		138, 0, 0, 7314, 7315, 5, 189, 0, 0, 7315, 7337, 3, 524, 262, 0, 7316,
		7338, 3, 106, 53, 0, 7317, 7318, 5, 191, 0, 0, 7318, 7319, 5, 77, 0, 0,
		7319, 7338, 5, 78, 0, 0, 7320, 7321, 5, 326, 0, 0, 7321, 7322, 5, 77, 0,
		0, 7322, 7338, 5, 78, 0, 0, 7323, 7324, 5, 133, 0, 0, 7324, 7338, 3, 208,
		104, 0, 7325, 7326, 5, 191, 0, 0, 7326, 7329, 5, 45, 0, 0, 7327, 7328,
		5, 220, 0, 0, 7328, 7330, 5, 389, 0, 0, 7329, 7327, 1, 0, 0, 0, 7329, 7330,
		1, 0, 0, 0, 7330, 7331, 1, 0, 0, 0, 7331, 7332, 3, 1340, 670, 0, 7332,
		7333, 3, 108, 54, 0, 7333, 7338, 1, 0, 0, 0, 7334, 7335, 5, 365, 0, 0,
		7335, 7336, 5, 45, 0, 0, 7336, 7338, 3, 1340, 670, 0, 7337, 7316, 1, 0,
		0, 0, 7337, 7317, 1, 0, 0, 0, 7337, 7320, 1, 0, 0, 0, 7337, 7323, 1, 0,
		0, 0, 7337, 7325, 1, 0, 0, 0, 7337, 7334, 1, 0, 0, 0, 7338, 833, 1, 0,
		0, 0, 7339, 7342, 5, 36, 0, 0, 7340, 7342, 1, 0, 0, 0, 7341, 7339, 1, 0,
		0, 0, 7341, 7340, 1, 0, 0, 0, 7342, 835, 1, 0, 0, 0, 7343, 7344, 5, 138,
		0, 0, 7344, 7345, 5, 348, 0, 0, 7345, 7346, 5, 318, 0, 0, 7346, 7347, 5,
		185, 0, 0, 7347, 7348, 3, 524, 262, 0, 7348, 7349, 3, 460, 230, 0, 7349,
		837, 1, 0, 0, 0, 7350, 7351, 5, 138, 0, 0, 7351, 7352, 5, 348, 0, 0, 7352,
		7353, 5, 318, 0, 0, 7353, 7354, 5, 163, 0, 0, 7354, 7355, 3, 524, 262,
		0, 7355, 7356, 5, 133, 0, 0, 7356, 7357, 5, 248, 0, 0, 7357, 7358, 5, 62,
		0, 0, 7358, 7359, 3, 1338, 669, 0, 7359, 7360, 3, 840, 420, 0, 7360, 7361,
		3, 522, 261, 0, 7361, 7423, 1, 0, 0, 0, 7362, 7363, 5, 138, 0, 0, 7363,
		7364, 5, 348, 0, 0, 7364, 7365, 5, 318, 0, 0, 7365, 7366, 5, 163, 0, 0,
		7366, 7367, 3, 524, 262, 0, 7367, 7368, 5, 138, 0, 0, 7368, 7369, 5, 248,
		0, 0, 7369, 7370, 5, 62, 0, 0, 7370, 7371, 3, 1338, 669, 0, 7371, 7372,
		3, 840, 420, 0, 7372, 7373, 3, 522, 261, 0, 7373, 7423, 1, 0, 0, 0, 7374,
		7375, 5, 138, 0, 0, 7375, 7376, 5, 348, 0, 0, 7376, 7377, 5, 318, 0, 0,
		7377, 7378, 5, 163, 0, 0, 7378, 7379, 3, 524, 262, 0, 7379, 7380, 5, 138,
		0, 0, 7380, 7381, 5, 248, 0, 0, 7381, 7382, 5, 304, 0, 0, 7382, 7383, 3,
		524, 262, 0, 7383, 7384, 3, 840, 420, 0, 7384, 7385, 3, 524, 262, 0, 7385,
		7423, 1, 0, 0, 0, 7386, 7387, 5, 138, 0, 0, 7387, 7388, 5, 348, 0, 0, 7388,
		7389, 5, 318, 0, 0, 7389, 7390, 5, 163, 0, 0, 7390, 7391, 3, 524, 262,
		0, 7391, 7392, 5, 138, 0, 0, 7392, 7393, 5, 248, 0, 0, 7393, 7394, 5, 62,
		0, 0, 7394, 7395, 3, 1338, 669, 0, 7395, 7396, 5, 304, 0, 0, 7396, 7397,
		3, 524, 262, 0, 7397, 7398, 3, 840, 420, 0, 7398, 7399, 3, 524, 262, 0,
		7399, 7423, 1, 0, 0, 0, 7400, 7401, 5, 138, 0, 0, 7401, 7402, 5, 348, 0,
		0, 7402, 7403, 5, 318, 0, 0, 7403, 7404, 5, 163, 0, 0, 7404, 7405, 3, 524,
		262, 0, 7405, 7406, 5, 191, 0, 0, 7406, 7407, 5, 248, 0, 0, 7407, 7408,
		5, 62, 0, 0, 7408, 7409, 3, 1338, 669, 0, 7409, 7423, 1, 0, 0, 0, 7410,
		7411, 5, 138, 0, 0, 7411, 7412, 5, 348, 0, 0, 7412, 7413, 5, 318, 0, 0,
		7413, 7414, 5, 163, 0, 0, 7414, 7415, 3, 524, 262, 0, 7415, 7416, 5, 191,
		0, 0, 7416, 7417, 5, 248, 0, 0, 7417, 7418, 5, 220, 0, 0, 7418, 7419, 5,
		389, 0, 0, 7419, 7420, 5, 62, 0, 0, 7420, 7421, 3, 1338, 669, 0, 7421,
		7423, 1, 0, 0, 0, 7422, 7350, 1, 0, 0, 0, 7422, 7362, 1, 0, 0, 0, 7422,
		7374, 1, 0, 0, 0, 7422, 7386, 1, 0, 0, 0, 7422, 7400, 1, 0, 0, 0, 7422,
		7410, 1, 0, 0, 0, 7423, 839, 1, 0, 0, 0, 7424, 7425, 5, 105, 0, 0, 7425,
		841, 1, 0, 0, 0, 7426, 7427, 5, 46, 0, 0, 7427, 7428, 3, 488, 244, 0, 7428,
		7429, 5, 168, 0, 0, 7429, 7430, 3, 524, 262, 0, 7430, 7431, 5, 62, 0, 0,
		7431, 7432, 3, 1358, 679, 0, 7432, 7433, 5, 94, 0, 0, 7433, 7434, 3, 1358,
		679, 0, 7434, 7435, 5, 64, 0, 0, 7435, 7436, 3, 524, 262, 0, 7436, 843,
		1, 0, 0, 0, 7437, 7438, 5, 158, 0, 0, 7438, 7439, 3, 864, 432, 0, 7439,
		7440, 3, 1336, 668, 0, 7440, 7441, 3, 846, 423, 0, 7441, 7451, 1, 0, 0,
		0, 7442, 7443, 5, 158, 0, 0, 7443, 7451, 3, 864, 432, 0, 7444, 7445, 5,
		158, 0, 0, 7445, 7446, 3, 864, 432, 0, 7446, 7447, 3, 1340, 670, 0, 7447,
		7448, 5, 80, 0, 0, 7448, 7449, 3, 1336, 668, 0, 7449, 7451, 1, 0, 0, 0,
		7450, 7437, 1, 0, 0, 0, 7450, 7442, 1, 0, 0, 0, 7450, 7444, 1, 0, 0, 0,
		7451, 845, 1, 0, 0, 0, 7452, 7453, 5, 100, 0, 0, 7453, 7456, 3, 1340, 670,
		0, 7454, 7456, 1, 0, 0, 0, 7455, 7452, 1, 0, 0, 0, 7455, 7454, 1, 0, 0,
		0, 7456, 847, 1, 0, 0, 0, 7457, 7458, 5, 363, 0, 0, 7458, 7459, 3, 866,
		433, 0, 7459, 7460, 3, 868, 434, 0, 7460, 7461, 3, 864, 432, 0, 7461, 7462,
		3, 862, 431, 0, 7462, 7463, 3, 876, 438, 0, 7463, 7471, 1, 0, 0, 0, 7464,
		7465, 5, 363, 0, 0, 7465, 7466, 5, 2, 0, 0, 7466, 7467, 3, 852, 426, 0,
		7467, 7468, 5, 3, 0, 0, 7468, 7469, 3, 876, 438, 0, 7469, 7471, 1, 0, 0,
		0, 7470, 7457, 1, 0, 0, 0, 7470, 7464, 1, 0, 0, 0, 7471, 849, 1, 0, 0,
		0, 7472, 7473, 3, 854, 427, 0, 7473, 7474, 3, 864, 432, 0, 7474, 7475,
		3, 876, 438, 0, 7475, 7483, 1, 0, 0, 0, 7476, 7477, 3, 854, 427, 0, 7477,
		7478, 5, 2, 0, 0, 7478, 7479, 3, 852, 426, 0, 7479, 7480, 5, 3, 0, 0, 7480,
		7481, 3, 876, 438, 0, 7481, 7483, 1, 0, 0, 0, 7482, 7472, 1, 0, 0, 0, 7482,
		7476, 1, 0, 0, 0, 7483, 851, 1, 0, 0, 0, 7484, 7489, 3, 856, 428, 0, 7485,
		7486, 5, 6, 0, 0, 7486, 7488, 3, 856, 428, 0, 7487, 7485, 1, 0, 0, 0, 7488,
		7491, 1, 0, 0, 0, 7489, 7487, 1, 0, 0, 0, 7489, 7490, 1, 0, 0, 0, 7490,
		853, 1, 0, 0, 0, 7491, 7489, 1, 0, 0, 0, 7492, 7493, 7, 34, 0, 0, 7493,
		855, 1, 0, 0, 0, 7494, 7495, 3, 858, 429, 0, 7495, 7496, 3, 860, 430, 0,
		7496, 857, 1, 0, 0, 0, 7497, 7500, 3, 1378, 689, 0, 7498, 7500, 3, 854,
		427, 0, 7499, 7497, 1, 0, 0, 0, 7499, 7498, 1, 0, 0, 0, 7500, 859, 1, 0,
		0, 0, 7501, 7505, 3, 66, 33, 0, 7502, 7505, 3, 292, 146, 0, 7503, 7505,
		1, 0, 0, 0, 7504, 7501, 1, 0, 0, 0, 7504, 7502, 1, 0, 0, 0, 7504, 7503,
		1, 0, 0, 0, 7505, 861, 1, 0, 0, 0, 7506, 7509, 3, 854, 427, 0, 7507, 7509,
		1, 0, 0, 0, 7508, 7506, 1, 0, 0, 0, 7508, 7507, 1, 0, 0, 0, 7509, 863,
		1, 0, 0, 0, 7510, 7513, 5, 128, 0, 0, 7511, 7513, 1, 0, 0, 0, 7512, 7510,
		1, 0, 0, 0, 7512, 7511, 1, 0, 0, 0, 7513, 865, 1, 0, 0, 0, 7514, 7517,
		5, 113, 0, 0, 7515, 7517, 1, 0, 0, 0, 7516, 7514, 1, 0, 0, 0, 7516, 7515,
		1, 0, 0, 0, 7517, 867, 1, 0, 0, 0, 7518, 7521, 5, 112, 0, 0, 7519, 7521,
		1, 0, 0, 0, 7520, 7518, 1, 0, 0, 0, 7520, 7519, 1, 0, 0, 0, 7521, 869,
		1, 0, 0, 0, 7522, 7523, 5, 2, 0, 0, 7523, 7524, 3, 1338, 669, 0, 7524,
		7525, 5, 3, 0, 0, 7525, 7528, 1, 0, 0, 0, 7526, 7528, 1, 0, 0, 0, 7527,
		7522, 1, 0, 0, 0, 7527, 7526, 1, 0, 0, 0, 7528, 871, 1, 0, 0, 0, 7529,
		7530, 3, 1336, 668, 0, 7530, 7531, 3, 870, 435, 0, 7531, 873, 1, 0, 0,
		0, 7532, 7537, 3, 872, 436, 0, 7533, 7534, 5, 6, 0, 0, 7534, 7536, 3, 872,
		436, 0, 7535, 7533, 1, 0, 0, 0, 7536, 7539, 1, 0, 0, 0, 7537, 7535, 1,
		0, 0, 0, 7537, 7538, 1, 0, 0, 0, 7538, 875, 1, 0, 0, 0, 7539, 7537, 1,
		0, 0, 0, 7540, 7543, 3, 874, 437, 0, 7541, 7543, 1, 0, 0, 0, 7542, 7540,
		1, 0, 0, 0, 7542, 7541, 1, 0, 0, 0, 7543, 877, 1, 0, 0, 0, 7544, 7545,
		5, 203, 0, 0, 7545, 7561, 3, 880, 440, 0, 7546, 7547, 5, 203, 0, 0, 7547,
		7548, 3, 854, 427, 0, 7548, 7549, 3, 864, 432, 0, 7549, 7550, 3, 880, 440,
		0, 7550, 7561, 1, 0, 0, 0, 7551, 7552, 5, 203, 0, 0, 7552, 7553, 5, 128,
		0, 0, 7553, 7561, 3, 880, 440, 0, 7554, 7555, 5, 203, 0, 0, 7555, 7556,
		5, 2, 0, 0, 7556, 7557, 3, 882, 441, 0, 7557, 7558, 5, 3, 0, 0, 7558, 7559,
		3, 880, 440, 0, 7559, 7561, 1, 0, 0, 0, 7560, 7544, 1, 0, 0, 0, 7560, 7546,
		1, 0, 0, 0, 7560, 7551, 1, 0, 0, 0, 7560, 7554, 1, 0, 0, 0, 7561, 879,
		1, 0, 0, 0, 7562, 7572, 3, 960, 480, 0, 7563, 7572, 3, 902, 451, 0, 7564,
		7572, 3, 942, 471, 0, 7565, 7572, 3, 928, 464, 0, 7566, 7572, 3, 952, 476,
		0, 7567, 7572, 3, 264, 132, 0, 7568, 7572, 3, 270, 135, 0, 7569, 7572,
		3, 276, 138, 0, 7570, 7572, 3, 896, 448, 0, 7571, 7562, 1, 0, 0, 0, 7571,
		7563, 1, 0, 0, 0, 7571, 7564, 1, 0, 0, 0, 7571, 7565, 1, 0, 0, 0, 7571,
		7566, 1, 0, 0, 0, 7571, 7567, 1, 0, 0, 0, 7571, 7568, 1, 0, 0, 0, 7571,
		7569, 1, 0, 0, 0, 7571, 7570, 1, 0, 0, 0, 7572, 881, 1, 0, 0, 0, 7573,
		7578, 3, 884, 442, 0, 7574, 7575, 5, 6, 0, 0, 7575, 7577, 3, 884, 442,
		0, 7576, 7574, 1, 0, 0, 0, 7577, 7580, 1, 0, 0, 0, 7578, 7576, 1, 0, 0,
		0, 7578, 7579, 1, 0, 0, 0, 7579, 883, 1, 0, 0, 0, 7580, 7578, 1, 0, 0,
		0, 7581, 7582, 3, 886, 443, 0, 7582, 7583, 3, 888, 444, 0, 7583, 885, 1,
		0, 0, 0, 7584, 7587, 3, 1378, 689, 0, 7585, 7587, 3, 854, 427, 0, 7586,
		7584, 1, 0, 0, 0, 7586, 7585, 1, 0, 0, 0, 7587, 887, 1, 0, 0, 0, 7588,
		7592, 3, 66, 33, 0, 7589, 7592, 3, 292, 146, 0, 7590, 7592, 1, 0, 0, 0,
		7591, 7588, 1, 0, 0, 0, 7591, 7589, 1, 0, 0, 0, 7591, 7590, 1, 0, 0, 0,
		7592, 889, 1, 0, 0, 0, 7593, 7594, 5, 283, 0, 0, 7594, 7595, 3, 1340, 670,
		0, 7595, 7596, 3, 892, 446, 0, 7596, 7597, 5, 36, 0, 0, 7597, 7598, 3,
		894, 447, 0, 7598, 891, 1, 0, 0, 0, 7599, 7600, 5, 2, 0, 0, 7600, 7601,
		3, 1286, 643, 0, 7601, 7602, 5, 3, 0, 0, 7602, 7605, 1, 0, 0, 0, 7603,
		7605, 1, 0, 0, 0, 7604, 7599, 1, 0, 0, 0, 7604, 7603, 1, 0, 0, 0, 7605,
		893, 1, 0, 0, 0, 7606, 7611, 3, 960, 480, 0, 7607, 7611, 3, 902, 451, 0,
		7608, 7611, 3, 942, 471, 0, 7609, 7611, 3, 928, 464, 0, 7610, 7606, 1,
		0, 0, 0, 7610, 7607, 1, 0, 0, 0, 7610, 7608, 1, 0, 0, 0, 7610, 7609, 1,
		0, 0, 0, 7611, 895, 1, 0, 0, 0, 7612, 7613, 5, 202, 0, 0, 7613, 7614, 3,
		1340, 670, 0, 7614, 7615, 3, 898, 449, 0, 7615, 7640, 1, 0, 0, 0, 7616,
		7617, 5, 46, 0, 0, 7617, 7618, 3, 174, 87, 0, 7618, 7619, 5, 92, 0, 0,
		7619, 7620, 3, 266, 133, 0, 7620, 7621, 5, 36, 0, 0, 7621, 7622, 5, 202,
		0, 0, 7622, 7623, 3, 1340, 670, 0, 7623, 7624, 3, 898, 449, 0, 7624, 7625,
		3, 268, 134, 0, 7625, 7640, 1, 0, 0, 0, 7626, 7627, 5, 46, 0, 0, 7627,
		7628, 3, 174, 87, 0, 7628, 7629, 5, 92, 0, 0, 7629, 7630, 5, 220, 0, 0,
		7630, 7631, 5, 77, 0, 0, 7631, 7632, 5, 389, 0, 0, 7632, 7633, 3, 266,
		133, 0, 7633, 7634, 5, 36, 0, 0, 7634, 7635, 5, 202, 0, 0, 7635, 7636,
		3, 1340, 670, 0, 7636, 7637, 3, 898, 449, 0, 7637, 7638, 3, 268, 134, 0,
		7638, 7640, 1, 0, 0, 0, 7639, 7612, 1, 0, 0, 0, 7639, 7616, 1, 0, 0, 0,
		7639, 7626, 1, 0, 0, 0, 7640, 897, 1, 0, 0, 0, 7641, 7642, 5, 2, 0, 0,
		7642, 7643, 3, 1280, 640, 0, 7643, 7644, 5, 3, 0, 0, 7644, 7647, 1, 0,
		0, 0, 7645, 7647, 1, 0, 0, 0, 7646, 7641, 1, 0, 0, 0, 7646, 7645, 1, 0,
		0, 0, 7647, 899, 1, 0, 0, 0, 7648, 7649, 5, 177, 0, 0, 7649, 7659, 3, 1340,
		670, 0, 7650, 7651, 5, 177, 0, 0, 7651, 7652, 5, 283, 0, 0, 7652, 7659,
		3, 1340, 670, 0, 7653, 7654, 5, 177, 0, 0, 7654, 7659, 5, 30, 0, 0, 7655,
		7656, 5, 177, 0, 0, 7656, 7657, 5, 283, 0, 0, 7657, 7659, 5, 30, 0, 0,
		7658, 7648, 1, 0, 0, 0, 7658, 7650, 1, 0, 0, 0, 7658, 7653, 1, 0, 0, 0,
		7658, 7655, 1, 0, 0, 0, 7659, 901, 1, 0, 0, 0, 7660, 7661, 3, 980, 490,
		0, 7661, 7662, 5, 232, 0, 0, 7662, 7663, 5, 71, 0, 0, 7663, 7664, 3, 904,
		452, 0, 7664, 7665, 3, 906, 453, 0, 7665, 7666, 3, 914, 457, 0, 7666, 7667,
		3, 918, 459, 0, 7667, 903, 1, 0, 0, 0, 7668, 7671, 3, 1336, 668, 0, 7669,
		7670, 5, 36, 0, 0, 7670, 7672, 3, 1372, 686, 0, 7671, 7669, 1, 0, 0, 0,
		7671, 7672, 1, 0, 0, 0, 7672, 905, 1, 0, 0, 0, 7673, 7693, 3, 960, 480,
		0, 7674, 7675, 5, 463, 0, 0, 7675, 7676, 3, 908, 454, 0, 7676, 7677, 5,
		450, 0, 0, 7677, 7678, 3, 960, 480, 0, 7678, 7693, 1, 0, 0, 0, 7679, 7680,
		5, 2, 0, 0, 7680, 7681, 3, 910, 455, 0, 7681, 7686, 5, 3, 0, 0, 7682, 7683,
		5, 463, 0, 0, 7683, 7684, 3, 908, 454, 0, 7684, 7685, 5, 450, 0, 0, 7685,
		7687, 1, 0, 0, 0, 7686, 7682, 1, 0, 0, 0, 7686, 7687, 1, 0, 0, 0, 7687,
		7688, 1, 0, 0, 0, 7688, 7689, 3, 960, 480, 0, 7689, 7693, 1, 0, 0, 0, 7690,
		7691, 5, 53, 0, 0, 7691, 7693, 5, 415, 0, 0, 7692, 7673, 1, 0, 0, 0, 7692,
		7674, 1, 0, 0, 0, 7692, 7679, 1, 0, 0, 0, 7692, 7690, 1, 0, 0, 0, 7693,
		907, 1, 0, 0, 0, 7694, 7695, 7, 35, 0, 0, 7695, 909, 1, 0, 0, 0, 7696,
		7701, 3, 912, 456, 0, 7697, 7698, 5, 6, 0, 0, 7698, 7700, 3, 912, 456,
		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, 911, 1, 0, 0, 0, 7703, 7701, 1, 0, 0,
		0, 7704, 7705, 3, 1372, 686, 0, 7705, 7706, 3, 1326, 663, 0, 7706, 913,
		1, 0, 0, 0, 7707, 7708, 5, 80, 0, 0, 7708, 7709, 5, 464, 0, 0, 7709, 7710,
		3, 916, 458, 0, 7710, 7717, 5, 57, 0, 0, 7711, 7712, 5, 362, 0, 0, 7712,
		7713, 5, 326, 0, 0, 7713, 7714, 3, 944, 472, 0, 7714, 7715, 3, 1094, 547,
		0, 7715, 7718, 1, 0, 0, 0, 7716, 7718, 5, 263, 0, 0, 7717, 7711, 1, 0,
		0, 0, 7717, 7716, 1, 0, 0, 0, 7718, 7721, 1, 0, 0, 0, 7719, 7721, 1, 0,
		0, 0, 7720, 7707, 1, 0, 0, 0, 7720, 7719, 1, 0, 0, 0, 7721, 915, 1, 0,
		0, 0, 7722, 7723, 5, 2, 0, 0, 7723, 7724, 3, 598, 299, 0, 7724, 7725, 5,
		3, 0, 0, 7725, 7726, 3, 1094, 547, 0, 7726, 7732, 1, 0, 0, 0, 7727, 7728,
		5, 80, 0, 0, 7728, 7729, 5, 45, 0, 0, 7729, 7732, 3, 1340, 670, 0, 7730,
		7732, 1, 0, 0, 0, 7731, 7722, 1, 0, 0, 0, 7731, 7727, 1, 0, 0, 0, 7731,
		7730, 1, 0, 0, 0, 7732, 917, 1, 0, 0, 0, 7733, 7734, 5, 87, 0, 0, 7734,
		7737, 3, 1330, 665, 0, 7735, 7737, 1, 0, 0, 0, 7736, 7733, 1, 0, 0, 0,
		7736, 7735, 1, 0, 0, 0, 7737, 919, 1, 0, 0, 0, 7738, 7740, 5, 253, 0, 0,
		7739, 7741, 5, 71, 0, 0, 7740, 7739, 1, 0, 0, 0, 7740, 7741, 1, 0, 0, 0,
		7741, 7742, 1, 0, 0, 0, 7742, 7744, 3, 1336, 668, 0, 7743, 7745, 3, 1062,
		531, 0, 7744, 7743, 1, 0, 0, 0, 7744, 7745, 1, 0, 0, 0, 7745, 7746, 1,
		0, 0, 0, 7746, 7749, 5, 100, 0, 0, 7747, 7750, 3, 962, 481, 0, 7748, 7750,
		3, 1336, 668, 0, 7749, 7747, 1, 0, 0, 0, 7749, 7748, 1, 0, 0, 0, 7750,
		7752, 1, 0, 0, 0, 7751, 7753, 3, 1062, 531, 0, 7752, 7751, 1, 0, 0, 0,
		7752, 7753, 1, 0, 0, 0, 7753, 7754, 1, 0, 0, 0, 7754, 7755, 5, 80, 0, 0,
		7755, 7764, 3, 1162, 581, 0, 7756, 7758, 3, 922, 461, 0, 7757, 7759, 3,
		924, 462, 0, 7758, 7757, 1, 0, 0, 0, 7758, 7759, 1, 0, 0, 0, 7759, 7765,
		1, 0, 0, 0, 7760, 7762, 3, 924, 462, 0, 7761, 7763, 3, 922, 461, 0, 7762,
		7761, 1, 0, 0, 0, 7762, 7763, 1, 0, 0, 0, 7763, 7765, 1, 0, 0, 0, 7764,
		7756, 1, 0, 0, 0, 7764, 7760, 1, 0, 0, 0, 7765, 7767, 1, 0, 0, 0, 7766,
		7768, 3, 926, 463, 0, 7767, 7766, 1, 0, 0, 0, 7767, 7768, 1, 0, 0, 0, 7768,
		921, 1, 0, 0, 0, 7769, 7770, 5, 102, 0, 0, 7770, 7771, 5, 77, 0, 0, 7771,
		7774, 5, 250, 0, 0, 7772, 7773, 5, 33, 0, 0, 7773, 7775, 3, 1162, 581,
		0, 7774, 7772, 1, 0, 0, 0, 7774, 7775, 1, 0, 0, 0, 7775, 7777, 1, 0, 0,
		0, 7776, 7778, 5, 93, 0, 0, 7777, 7776, 1, 0, 0, 0, 7777, 7778, 1, 0, 0,
		0, 7778, 7779, 1, 0, 0, 0, 7779, 7784, 5, 232, 0, 0, 7780, 7781, 5, 2,
		0, 0, 7781, 7782, 3, 910, 455, 0, 7782, 7783, 5, 3, 0, 0, 7783, 7785, 1,
		0, 0, 0, 7784, 7780, 1, 0, 0, 0, 7784, 7785, 1, 0, 0, 0, 7785, 7786, 1,
		0, 0, 0, 7786, 7787, 3, 1052, 526, 0, 7787, 923, 1, 0, 0, 0, 7788, 7789,
		5, 102, 0, 0, 7789, 7792, 5, 250, 0, 0, 7790, 7791, 5, 33, 0, 0, 7791,
		7793, 3, 1162, 581, 0, 7792, 7790, 1, 0, 0, 0, 7792, 7793, 1, 0, 0, 0,
		7793, 7795, 1, 0, 0, 0, 7794, 7796, 5, 93, 0, 0, 7795, 7794, 1, 0, 0, 0,
		7795, 7796, 1, 0, 0, 0, 7796, 7797, 1, 0, 0, 0, 7797, 7798, 5, 362, 0,
		0, 7798, 7799, 5, 326, 0, 0, 7799, 7800, 3, 944, 472, 0, 7800, 925, 1,
		0, 0, 0, 7801, 7802, 5, 102, 0, 0, 7802, 7804, 5, 250, 0, 0, 7803, 7805,
		5, 93, 0, 0, 7804, 7803, 1, 0, 0, 0, 7804, 7805, 1, 0, 0, 0, 7805, 7806,
		1, 0, 0, 0, 7806, 7807, 5, 182, 0, 0, 7807, 927, 1, 0, 0, 0, 7808, 7809,
		3, 980, 490, 0, 7809, 7810, 5, 182, 0, 0, 7810, 7811, 5, 64, 0, 0, 7811,
		7812, 3, 1078, 539, 0, 7812, 7813, 3, 930, 465, 0, 7813, 7814, 3, 1096,
		548, 0, 7814, 7815, 3, 918, 459, 0, 7815, 929, 1, 0, 0, 0, 7816, 7817,
		5, 100, 0, 0, 7817, 7820, 3, 1056, 528, 0, 7818, 7820, 1, 0, 0, 0, 7819,
		7816, 1, 0, 0, 0, 7819, 7818, 1, 0, 0, 0, 7820, 931, 1, 0, 0, 0, 7821,
		7822, 5, 247, 0, 0, 7822, 7823, 3, 988, 494, 0, 7823, 7824, 3, 1076, 538,
		0, 7824, 7825, 3, 934, 467, 0, 7825, 7826, 3, 938, 469, 0, 7826, 933, 1,
		0, 0, 0, 7827, 7828, 5, 68, 0, 0, 7828, 7829, 3, 936, 468, 0, 7829, 7830,
		5, 256, 0, 0, 7830, 7833, 1, 0, 0, 0, 7831, 7833, 1, 0, 0, 0, 7832, 7827,
		1, 0, 0, 0, 7832, 7831, 1, 0, 0, 0, 7833, 935, 1, 0, 0, 0, 7834, 7835,
		5, 131, 0, 0, 7835, 7847, 7, 36, 0, 0, 7836, 7837, 5, 407, 0, 0, 7837,
		7847, 7, 36, 0, 0, 7838, 7843, 5, 327, 0, 0, 7839, 7840, 5, 362, 0, 0,
		7840, 7844, 5, 201, 0, 0, 7841, 7842, 5, 407, 0, 0, 7842, 7844, 5, 201,
		0, 0, 7843, 7839, 1, 0, 0, 0, 7843, 7841, 1, 0, 0, 0, 7843, 7844, 1, 0,
		0, 0, 7844, 7847, 1, 0, 0, 0, 7845, 7847, 5, 201, 0, 0, 7846, 7834, 1,
		0, 0, 0, 7846, 7836, 1, 0, 0, 0, 7846, 7838, 1, 0, 0, 0, 7846, 7845, 1,
		0, 0, 0, 7847, 937, 1, 0, 0, 0, 7848, 7851, 5, 265, 0, 0, 7849, 7851, 1,
		0, 0, 0, 7850, 7848, 1, 0, 0, 0, 7850, 7849, 1, 0, 0, 0, 7851, 939, 1,
		0, 0, 0, 7852, 7857, 5, 265, 0, 0, 7853, 7854, 5, 465, 0, 0, 7854, 7857,
		5, 466, 0, 0, 7855, 7857, 1, 0, 0, 0, 7856, 7852, 1, 0, 0, 0, 7856, 7853,
		1, 0, 0, 0, 7856, 7855, 1, 0, 0, 0, 7857, 941, 1, 0, 0, 0, 7858, 7859,
		3, 980, 490, 0, 7859, 7860, 5, 362, 0, 0, 7860, 7861, 3, 1078, 539, 0,
		7861, 7862, 5, 326, 0, 0, 7862, 7863, 3, 944, 472, 0, 7863, 7864, 3, 1054,
		527, 0, 7864, 7865, 3, 1096, 548, 0, 7865, 7866, 3, 918, 459, 0, 7866,
		943, 1, 0, 0, 0, 7867, 7872, 3, 946, 473, 0, 7868, 7869, 5, 6, 0, 0, 7869,
		7871, 3, 946, 473, 0, 7870, 7868, 1, 0, 0, 0, 7871, 7874, 1, 0, 0, 0, 7872,
		7870, 1, 0, 0, 0, 7872, 7873, 1, 0, 0, 0, 7873, 945, 1, 0, 0, 0, 7874,
		7872, 1, 0, 0, 0, 7875, 7876, 3, 948, 474, 0, 7876, 7877, 5, 10, 0, 0,
		7877, 7878, 3, 1162, 581, 0, 7878, 7886, 1, 0, 0, 0, 7879, 7880, 5, 2,
		0, 0, 7880, 7881, 3, 950, 475, 0, 7881, 7882, 5, 3, 0, 0, 7882, 7883, 5,
		10, 0, 0, 7883, 7884, 3, 1162, 581, 0, 7884, 7886, 1, 0, 0, 0, 7885, 7875,
		1, 0, 0, 0, 7885, 7879, 1, 0, 0, 0, 7886, 947, 1, 0, 0, 0, 7887, 7888,
		3, 1372, 686, 0, 7888, 7889, 3, 1326, 663, 0, 7889, 949, 1, 0, 0, 0, 7890,
		7895, 3, 948, 474, 0, 7891, 7892, 5, 6, 0, 0, 7892, 7894, 3, 948, 474,
		0, 7893, 7891, 1, 0, 0, 0, 7894, 7897, 1, 0, 0, 0, 7895, 7893, 1, 0, 0,
		0, 7895, 7896, 1, 0, 0, 0, 7896, 951, 1, 0, 0, 0, 7897, 7895, 1, 0, 0,
		0, 7898, 7899, 5, 178, 0, 0, 7899, 7900, 3, 954, 477, 0, 7900, 7901, 3,
		956, 478, 0, 7901, 7902, 5, 172, 0, 0, 7902, 7903, 3, 958, 479, 0, 7903,
		7904, 5, 62, 0, 0, 7904, 7905, 3, 960, 480, 0, 7905, 953, 1, 0, 0, 0, 7906,
		7907, 3, 1340, 670, 0, 7907, 955, 1, 0, 0, 0, 7908, 7909, 5, 262, 0, 0,
		7909, 7914, 5, 317, 0, 0, 7910, 7914, 5, 317, 0, 0, 7911, 7914, 5, 107,
		0, 0, 7912, 7914, 5, 231, 0, 0, 7913, 7908, 1, 0, 0, 0, 7913, 7910, 1,
		0, 0, 0, 7913, 7911, 1, 0, 0, 0, 7913, 7912, 1, 0, 0, 0, 7914, 7917, 1,
		0, 0, 0, 7915, 7913, 1, 0, 0, 0, 7915, 7916, 1, 0, 0, 0, 7916, 957, 1,
		0, 0, 0, 7917, 7915, 1, 0, 0, 0, 7918, 7924, 1, 0, 0, 0, 7919, 7920, 5,
		105, 0, 0, 7920, 7924, 5, 217, 0, 0, 7921, 7922, 5, 372, 0, 0, 7922, 7924,
		5, 217, 0, 0, 7923, 7918, 1, 0, 0, 0, 7923, 7919, 1, 0, 0, 0, 7923, 7921,
		1, 0, 0, 0, 7924, 959, 1, 0, 0, 0, 7925, 7928, 3, 964, 482, 0, 7926, 7928,
		3, 962, 481, 0, 7927, 7925, 1, 0, 0, 0, 7927, 7926, 1, 0, 0, 0, 7928, 961,
		1, 0, 0, 0, 7929, 7930, 5, 2, 0, 0, 7930, 7931, 3, 964, 482, 0, 7931, 7932,
		5, 3, 0, 0, 7932, 7938, 1, 0, 0, 0, 7933, 7934, 5, 2, 0, 0, 7934, 7935,
		3, 962, 481, 0, 7935, 7936, 5, 3, 0, 0, 7936, 7938, 1, 0, 0, 0, 7937, 7929,
		1, 0, 0, 0, 7937, 7933, 1, 0, 0, 0, 7938, 963, 1, 0, 0, 0, 7939, 7940,
		3, 966, 483, 0, 7940, 7947, 3, 996, 498, 0, 7941, 7942, 3, 1040, 520, 0,
		7942, 7943, 3, 1006, 503, 0, 7943, 7948, 1, 0, 0, 0, 7944, 7945, 3, 1004,
		502, 0, 7945, 7946, 3, 1042, 521, 0, 7946, 7948, 1, 0, 0, 0, 7947, 7941,
		1, 0, 0, 0, 7947, 7944, 1, 0, 0, 0, 7947, 7948, 1, 0, 0, 0, 7948, 7961,
		1, 0, 0, 0, 7949, 7950, 3, 972, 486, 0, 7950, 7951, 3, 966, 483, 0, 7951,
		7958, 3, 996, 498, 0, 7952, 7953, 3, 1040, 520, 0, 7953, 7954, 3, 1006,
		503, 0, 7954, 7959, 1, 0, 0, 0, 7955, 7956, 3, 1004, 502, 0, 7956, 7957,
		3, 1042, 521, 0, 7957, 7959, 1, 0, 0, 0, 7958, 7952, 1, 0, 0, 0, 7958,
		7955, 1, 0, 0, 0, 7958, 7959, 1, 0, 0, 0, 7959, 7961, 1, 0, 0, 0, 7960,
		7939, 1, 0, 0, 0, 7960, 7949, 1, 0, 0, 0, 7961, 965, 1, 0, 0, 0, 7962,
		7969, 3, 968, 484, 0, 7963, 7964, 7, 37, 0, 0, 7964, 7965, 3, 990, 495,
		0, 7965, 7966, 3, 968, 484, 0, 7966, 7968, 1, 0, 0, 0, 7967, 7963, 1, 0,
		0, 0, 7968, 7971, 1, 0, 0, 0, 7969, 7967, 1, 0, 0, 0, 7969, 7970, 1, 0,
		0, 0, 7970, 967, 1, 0, 0, 0, 7971, 7969, 1, 0, 0, 0, 7972, 7979, 3, 970,
		485, 0, 7973, 7974, 5, 70, 0, 0, 7974, 7975, 3, 990, 495, 0, 7975, 7976,
		3, 970, 485, 0, 7976, 7978, 1, 0, 0, 0, 7977, 7973, 1, 0, 0, 0, 7978, 7981,
		1, 0, 0, 0, 7979, 7977, 1, 0, 0, 0, 7979, 7980, 1, 0, 0, 0, 7980, 969,
		1, 0, 0, 0, 7981, 7979, 1, 0, 0, 0, 7982, 7990, 5, 88, 0, 0, 7983, 7984,
		3, 994, 497, 0, 7984, 7985, 3, 982, 491, 0, 7985, 7986, 3, 1328, 664, 0,
		7986, 7991, 1, 0, 0, 0, 7987, 7988, 3, 992, 496, 0, 7988, 7989, 3, 1330,
		665, 0, 7989, 7991, 1, 0, 0, 0, 7990, 7983, 1, 0, 0, 0, 7990, 7987, 1,
		0, 0, 0, 7991, 7992, 1, 0, 0, 0, 7992, 7993, 3, 982, 491, 0, 7993, 7994,
		3, 1054, 527, 0, 7994, 7995, 3, 1094, 547, 0, 7995, 7996, 3, 1024, 512,
		0, 7996, 7997, 3, 1038, 519, 0, 7997, 7998, 3, 1240, 620, 0, 7998, 8004,
		1, 0, 0, 0, 7999, 8004, 3, 1052, 526, 0, 8000, 8001, 5, 92, 0, 0, 8001,
		8004, 3, 1074, 537, 0, 8002, 8004, 3, 962, 481, 0, 8003, 7982, 1, 0, 0,
		0, 8003, 7999, 1, 0, 0, 0, 8003, 8000, 1, 0, 0, 0, 8003, 8002, 1, 0, 0,
		0, 8004, 971, 1, 0, 0, 0, 8005, 8007, 5, 105, 0, 0, 8006, 8008, 5, 296,
		0, 0, 8007, 8006, 1, 0, 0, 0, 8007, 8008, 1, 0, 0, 0, 8008, 8009, 1, 0,
		0, 0, 8009, 8010, 3, 974, 487, 0, 8010, 973, 1, 0, 0, 0, 8011, 8016, 3,
		976, 488, 0, 8012, 8013, 5, 6, 0, 0, 8013, 8015, 3, 976, 488, 0, 8014,
		8012, 1, 0, 0, 0, 8015, 8018, 1, 0, 0, 0, 8016, 8014, 1, 0, 0, 0, 8016,
		8017, 1, 0, 0, 0, 8017, 975, 1, 0, 0, 0, 8018, 8016, 1, 0, 0, 0, 8019,
		8020, 3, 1340, 670, 0, 8020, 8021, 3, 870, 435, 0, 8021, 8022, 5, 36, 0,
		0, 8022, 8023, 3, 978, 489, 0, 8023, 8024, 5, 2, 0, 0, 8024, 8025, 3, 894,
		447, 0, 8025, 8026, 5, 3, 0, 0, 8026, 977, 1, 0, 0, 0, 8027, 8032, 5, 251,
		0, 0, 8028, 8029, 5, 77, 0, 0, 8029, 8032, 5, 251, 0, 0, 8030, 8032, 1,
		0, 0, 0, 8031, 8027, 1, 0, 0, 0, 8031, 8028, 1, 0, 0, 0, 8031, 8030, 1,
		0, 0, 0, 8032, 979, 1, 0, 0, 0, 8033, 8036, 3, 972, 486, 0, 8034, 8036,
		1, 0, 0, 0, 8035, 8033, 1, 0, 0, 0, 8035, 8034, 1, 0, 0, 0, 8036, 981,
		1, 0, 0, 0, 8037, 8042, 5, 71, 0, 0, 8038, 8039, 3, 984, 492, 0, 8039,
		8040, 3, 986, 493, 0, 8040, 8043, 1, 0, 0, 0, 8041, 8043, 3, 1566, 783,
		0, 8042, 8038, 1, 0, 0, 0, 8042, 8041, 1, 0, 0, 0, 8043, 8046, 1, 0, 0,
		0, 8044, 8046, 1, 0, 0, 0, 8045, 8037, 1, 0, 0, 0, 8045, 8044, 1, 0, 0,
		0, 8046, 983, 1, 0, 0, 0, 8047, 8050, 1, 0, 0, 0, 8048, 8050, 5, 339, 0,
		0, 8049, 8047, 1, 0, 0, 0, 8049, 8048, 1, 0, 0, 0, 8050, 985, 1, 0, 0,
		0, 8051, 8053, 7, 38, 0, 0, 8052, 8051, 1, 0, 0, 0, 8052, 8053, 1, 0, 0,
		0, 8053, 8054, 1, 0, 0, 0, 8054, 8055, 7, 11, 0, 0, 8055, 8056, 3, 988,
		494, 0, 8056, 8057, 3, 1336, 668, 0, 8057, 8066, 1, 0, 0, 0, 8058, 8059,
		5, 360, 0, 0, 8059, 8060, 3, 988, 494, 0, 8060, 8061, 3, 1336, 668, 0,
		8061, 8066, 1, 0, 0, 0, 8062, 8063, 5, 92, 0, 0, 8063, 8066, 3, 1336, 668,
		0, 8064, 8066, 3, 1336, 668, 0, 8065, 8052, 1, 0, 0, 0, 8065, 8058, 1,
		0, 0, 0, 8065, 8062, 1, 0, 0, 0, 8065, 8064, 1, 0, 0, 0, 8066, 987, 1,
		0, 0, 0, 8067, 8070, 5, 92, 0, 0, 8068, 8070, 1, 0, 0, 0, 8069, 8067, 1,
		0, 0, 0, 8069, 8068, 1, 0, 0, 0, 8070, 989, 1, 0, 0, 0, 8071, 8075, 5,
		30, 0, 0, 8072, 8075, 5, 56, 0, 0, 8073, 8075, 1, 0, 0, 0, 8074, 8071,
		1, 0, 0, 0, 8074, 8072, 1, 0, 0, 0, 8074, 8073, 1, 0, 0, 0, 8075, 991,
		1, 0, 0, 0, 8076, 8082, 5, 56, 0, 0, 8077, 8078, 5, 80, 0, 0, 8078, 8079,
		5, 2, 0, 0, 8079, 8080, 3, 1280, 640, 0, 8080, 8081, 5, 3, 0, 0, 8081,
		8083, 1, 0, 0, 0, 8082, 8077, 1, 0, 0, 0, 8082, 8083, 1, 0, 0, 0, 8083,
		993, 1, 0, 0, 0, 8084, 8087, 5, 30, 0, 0, 8085, 8087, 1, 0, 0, 0, 8086,
		8084, 1, 0, 0, 0, 8086, 8085, 1, 0, 0, 0, 8087, 995, 1, 0, 0, 0, 8088,
		8091, 3, 998, 499, 0, 8089, 8091, 1, 0, 0, 0, 8090, 8088, 1, 0, 0, 0, 8090,
		8089, 1, 0, 0, 0, 8091, 997, 1, 0, 0, 0, 8092, 8093, 5, 83, 0, 0, 8093,
		8094, 5, 147, 0, 0, 8094, 8095, 3, 1000, 500, 0, 8095, 999, 1, 0, 0, 0,
		8096, 8101, 3, 1002, 501, 0, 8097, 8098, 5, 6, 0, 0, 8098, 8100, 3, 1002,
		501, 0, 8099, 8097, 1, 0, 0, 0, 8100, 8103, 1, 0, 0, 0, 8101, 8099, 1,
		0, 0, 0, 8101, 8102, 1, 0, 0, 0, 8102, 1001, 1, 0, 0, 0, 8103, 8101, 1,
		0, 0, 0, 8104, 8108, 3, 1162, 581, 0, 8105, 8106, 5, 100, 0, 0, 8106, 8109,
		3, 1276, 638, 0, 8107, 8109, 3, 612, 306, 0, 8108, 8105, 1, 0, 0, 0, 8108,
		8107, 1, 0, 0, 0, 8109, 8110, 1, 0, 0, 0, 8110, 8111, 3, 614, 307, 0, 8111,
		1003, 1, 0, 0, 0, 8112, 8114, 3, 1008, 504, 0, 8113, 8115, 3, 1010, 505,
		0, 8114, 8113, 1, 0, 0, 0, 8114, 8115, 1, 0, 0, 0, 8115, 8121, 1, 0, 0,
		0, 8116, 8118, 3, 1010, 505, 0, 8117, 8119, 3, 1008, 504, 0, 8118, 8117,
		1, 0, 0, 0, 8118, 8119, 1, 0, 0, 0, 8119, 8121, 1, 0, 0, 0, 8120, 8112,
		1, 0, 0, 0, 8120, 8116, 1, 0, 0, 0, 8121, 1005, 1, 0, 0, 0, 8122, 8125,
		3, 1004, 502, 0, 8123, 8125, 1, 0, 0, 0, 8124, 8122, 1, 0, 0, 0, 8124,
		8123, 1, 0, 0, 0, 8125, 1007, 1, 0, 0, 0, 8126, 8127, 5, 74, 0, 0, 8127,
		8130, 3, 1012, 506, 0, 8128, 8129, 5, 6, 0, 0, 8129, 8131, 3, 1014, 507,
		0, 8130, 8128, 1, 0, 0, 0, 8130, 8131, 1, 0, 0, 0, 8131, 8150, 1, 0, 0,
		0, 8132, 8133, 5, 61, 0, 0, 8133, 8147, 3, 1022, 511, 0, 8134, 8135, 3,
		1016, 508, 0, 8135, 8139, 3, 1020, 510, 0, 8136, 8140, 5, 81, 0, 0, 8137,
		8138, 5, 105, 0, 0, 8138, 8140, 5, 467, 0, 0, 8139, 8136, 1, 0, 0, 0, 8139,
		8137, 1, 0, 0, 0, 8140, 8148, 1, 0, 0, 0, 8141, 8145, 3, 1020, 510, 0,
		8142, 8146, 5, 81, 0, 0, 8143, 8144, 5, 105, 0, 0, 8144, 8146, 5, 467,
		0, 0, 8145, 8142, 1, 0, 0, 0, 8145, 8143, 1, 0, 0, 0, 8146, 8148, 1, 0,
		0, 0, 8147, 8134, 1, 0, 0, 0, 8147, 8141, 1, 0, 0, 0, 8148, 8150, 1, 0,
		0, 0, 8149, 8126, 1, 0, 0, 0, 8149, 8132, 1, 0, 0, 0, 8150, 1009, 1, 0,
		0, 0, 8151, 8156, 5, 79, 0, 0, 8152, 8157, 3, 1014, 507, 0, 8153, 8154,
		3, 1016, 508, 0, 8154, 8155, 3, 1020, 510, 0, 8155, 8157, 1, 0, 0, 0, 8156,
		8152, 1, 0, 0, 0, 8156, 8153, 1, 0, 0, 0, 8157, 1011, 1, 0, 0, 0, 8158,
		8161, 3, 1162, 581, 0, 8159, 8161, 5, 30, 0, 0, 8160, 8158, 1, 0, 0, 0,
		8160, 8159, 1, 0, 0, 0, 8161, 1013, 1, 0, 0, 0, 8162, 8163, 3, 1162, 581,
		0, 8163, 1015, 1, 0, 0, 0, 8164, 8170, 3, 1206, 603, 0, 8165, 8166, 5,
		12, 0, 0, 8166, 8170, 3, 1018, 509, 0, 8167, 8168, 5, 13, 0, 0, 8168, 8170,
		3, 1018, 509, 0, 8169, 8164, 1, 0, 0, 0, 8169, 8165, 1, 0, 0, 0, 8169,
		8167, 1, 0, 0, 0, 8170, 1017, 1, 0, 0, 0, 8171, 8174, 3, 1356, 678, 0,
		8172, 8174, 3, 1354, 677, 0, 8173, 8171, 1, 0, 0, 0, 8173, 8172, 1, 0,
		0, 0, 8174, 1019, 1, 0, 0, 0, 8175, 8176, 7, 39, 0, 0, 8176, 1021, 1, 0,
		0, 0, 8177, 8178, 7, 40, 0, 0, 8178, 1023, 1, 0, 0, 0, 8179, 8180, 5, 66,
		0, 0, 8180, 8181, 5, 147, 0, 0, 8181, 8184, 3, 1026, 513, 0, 8182, 8184,
		1, 0, 0, 0, 8183, 8179, 1, 0, 0, 0, 8183, 8182, 1, 0, 0, 0, 8184, 1025,
		1, 0, 0, 0, 8185, 8190, 3, 1028, 514, 0, 8186, 8187, 5, 6, 0, 0, 8187,
		8189, 3, 1028, 514, 0, 8188, 8186, 1, 0, 0, 0, 8189, 8192, 1, 0, 0, 0,
		8190, 8188, 1, 0, 0, 0, 8190, 8191, 1, 0, 0, 0, 8191, 1027, 1, 0, 0, 0,
		8192, 8190, 1, 0, 0, 0, 8193, 8199, 3, 1030, 515, 0, 8194, 8199, 3, 1034,
		517, 0, 8195, 8199, 3, 1032, 516, 0, 8196, 8199, 3, 1036, 518, 0, 8197,
		8199, 3, 1162, 581, 0, 8198, 8193, 1, 0, 0, 0, 8198, 8194, 1, 0, 0, 0,
		8198, 8195, 1, 0, 0, 0, 8198, 8196, 1, 0, 0, 0, 8198, 8197, 1, 0, 0, 0,
		8199, 1029, 1, 0, 0, 0, 8200, 8201, 5, 2, 0, 0, 8201, 8202, 5, 3, 0, 0,
		8202, 1031, 1, 0, 0, 0, 8203, 8204, 5, 468, 0, 0, 8204, 8205, 5, 2, 0,
		0, 8205, 8206, 3, 1280, 640, 0, 8206, 8207, 5, 3, 0, 0, 8207, 1033, 1,
		0, 0, 0, 8208, 8209, 5, 469, 0, 0, 8209, 8210, 5, 2, 0, 0, 8210, 8211,
		3, 1280, 640, 0, 8211, 8212, 5, 3, 0, 0, 8212, 1035, 1, 0, 0, 0, 8213,
		8214, 5, 470, 0, 0, 8214, 8215, 5, 471, 0, 0, 8215, 8216, 5, 2, 0, 0, 8216,
		8217, 3, 1026, 513, 0, 8217, 8218, 5, 3, 0, 0, 8218, 1037, 1, 0, 0, 0,
		8219, 8220, 5, 67, 0, 0, 8220, 8223, 3, 1162, 581, 0, 8221, 8223, 1, 0,
		0, 0, 8222, 8219, 1, 0, 0, 0, 8222, 8221, 1, 0, 0, 0, 8223, 1039, 1, 0,
		0, 0, 8224, 8229, 3, 1044, 522, 0, 8225, 8226, 5, 62, 0, 0, 8226, 8227,
		5, 293, 0, 0, 8227, 8229, 5, 81, 0, 0, 8228, 8224, 1, 0, 0, 0, 8228, 8225,
		1, 0, 0, 0, 8229, 1041, 1, 0, 0, 0, 8230, 8233, 3, 1040, 520, 0, 8231,
		8233, 1, 0, 0, 0, 8232, 8230, 1, 0, 0, 0, 8232, 8231, 1, 0, 0, 0, 8233,
		1043, 1, 0, 0, 0, 8234, 8236, 3, 1046, 523, 0, 8235, 8234, 1, 0, 0, 0,
		8236, 8237, 1, 0, 0, 0, 8237, 8235, 1, 0, 0, 0, 8237, 8238, 1, 0, 0, 0,
		8238, 1045, 1, 0, 0, 0, 8239, 8240, 3, 1048, 524, 0, 8240, 8241, 3, 1050,
		525, 0, 8241, 8242, 3, 940, 470, 0, 8242, 1047, 1, 0, 0, 0, 8243, 8253,
		5, 62, 0, 0, 8244, 8245, 5, 262, 0, 0, 8245, 8247, 5, 236, 0, 0, 8246,
		8244, 1, 0, 0, 0, 8246, 8247, 1, 0, 0, 0, 8247, 8248, 1, 0, 0, 0, 8248,
		8254, 5, 362, 0, 0, 8249, 8251, 5, 236, 0, 0, 8250, 8249, 1, 0, 0, 0, 8250,
		8251, 1, 0, 0, 0, 8251, 8252, 1, 0, 0, 0, 8252, 8254, 5, 327, 0, 0, 8253,
		8246, 1, 0, 0, 0, 8253, 8250, 1, 0, 0, 0, 8254, 1049, 1, 0, 0, 0, 8255,
		8256, 5, 268, 0, 0, 8256, 8259, 3, 1334, 667, 0, 8257, 8259, 1, 0, 0, 0,
		8258, 8255, 1, 0, 0, 0, 8258, 8257, 1, 0, 0, 0, 8259, 1051, 1, 0, 0, 0,
		8260, 8261, 5, 415, 0, 0, 8261, 8262, 5, 2, 0, 0, 8262, 8263, 3, 1280,
		640, 0, 8263, 8271, 5, 3, 0, 0, 8264, 8265, 5, 6, 0, 0, 8265, 8266, 5,
		2, 0, 0, 8266, 8267, 3, 1280, 640, 0, 8267, 8268, 5, 3, 0, 0, 8268, 8270,
		1, 0, 0, 0, 8269, 8264, 1, 0, 0, 0, 8270, 8273, 1, 0, 0, 0, 8271, 8269,
		1, 0, 0, 0, 8271, 8272, 1, 0, 0, 0, 8272, 1053, 1, 0, 0, 0, 8273, 8271,
		1, 0, 0, 0, 8274, 8275, 5, 64, 0, 0, 8275, 8278, 3, 1056, 528, 0, 8276,
		8278, 1, 0, 0, 0, 8277, 8274, 1, 0, 0, 0, 8277, 8276, 1, 0, 0, 0, 8278,
		1055, 1, 0, 0, 0, 8279, 8289, 3, 1058, 529, 0, 8280, 8285, 3, 1060, 530,
		0, 8281, 8282, 5, 6, 0, 0, 8282, 8284, 3, 1060, 530, 0, 8283, 8281, 1,
		0, 0, 0, 8284, 8287, 1, 0, 0, 0, 8285, 8283, 1, 0, 0, 0, 8285, 8286, 1,
		0, 0, 0, 8286, 8289, 1, 0, 0, 0, 8287, 8285, 1, 0, 0, 0, 8288, 8279, 1,
		0, 0, 0, 8288, 8280, 1, 0, 0, 0, 8289, 1057, 1, 0, 0, 0, 8290, 8293, 3,
		1060, 530, 0, 8291, 8292, 5, 6, 0, 0, 8292, 8294, 3, 1060, 530, 0, 8293,
		8291, 1, 0, 0, 0, 8294, 8295, 1, 0, 0, 0, 8295, 8293, 1, 0, 0, 0, 8295,
		8296, 1, 0, 0, 0, 8296, 1059, 1, 0, 0, 0, 8297, 8298, 3, 1074, 537, 0,
		8298, 8300, 3, 1064, 532, 0, 8299, 8301, 3, 1080, 540, 0, 8300, 8299, 1,
		0, 0, 0, 8300, 8301, 1, 0, 0, 0, 8301, 8347, 1, 0, 0, 0, 8302, 8303, 3,
		1084, 542, 0, 8303, 8304, 3, 1068, 534, 0, 8304, 8347, 1, 0, 0, 0, 8305,
		8306, 3, 1104, 552, 0, 8306, 8307, 3, 1064, 532, 0, 8307, 8347, 1, 0, 0,
		0, 8308, 8309, 3, 962, 481, 0, 8309, 8310, 3, 1064, 532, 0, 8310, 8347,
		1, 0, 0, 0, 8311, 8321, 5, 72, 0, 0, 8312, 8313, 3, 1104, 552, 0, 8313,
		8314, 3, 1064, 532, 0, 8314, 8322, 1, 0, 0, 0, 8315, 8316, 3, 1084, 542,
		0, 8316, 8317, 3, 1068, 534, 0, 8317, 8322, 1, 0, 0, 0, 8318, 8319, 3,
		962, 481, 0, 8319, 8320, 3, 1064, 532, 0, 8320, 8322, 1, 0, 0, 0, 8321,
		8312, 1, 0, 0, 0, 8321, 8315, 1, 0, 0, 0, 8321, 8318, 1, 0, 0, 0, 8322,
		8347, 1, 0, 0, 0, 8323, 8324, 5, 2, 0, 0, 8324, 8341, 3, 1060, 530, 0,
		8325, 8326, 5, 110, 0, 0, 8326, 8327, 5, 118, 0, 0, 8327, 8342, 3, 1060,
		530, 0, 8328, 8330, 5, 121, 0, 0, 8329, 8331, 3, 1070, 535, 0, 8330, 8329,
		1, 0, 0, 0, 8330, 8331, 1, 0, 0, 0, 8331, 8332, 1, 0, 0, 0, 8332, 8333,
		5, 118, 0, 0, 8333, 8342, 3, 1060, 530, 0, 8334, 8336, 3, 1070, 535, 0,
		8335, 8334, 1, 0, 0, 0, 8335, 8336, 1, 0, 0, 0, 8336, 8337, 1, 0, 0, 0,
		8337, 8338, 5, 118, 0, 0, 8338, 8339, 3, 1060, 530, 0, 8339, 8340, 3, 1072,
		536, 0, 8340, 8342, 1, 0, 0, 0, 8341, 8325, 1, 0, 0, 0, 8341, 8328, 1,
		0, 0, 0, 8341, 8335, 1, 0, 0, 0, 8341, 8342, 1, 0, 0, 0, 8342, 8343, 1,
		0, 0, 0, 8343, 8344, 5, 3, 0, 0, 8344, 8345, 3, 1064, 532, 0, 8345, 8347,
		1, 0, 0, 0, 8346, 8297, 1, 0, 0, 0, 8346, 8302, 1, 0, 0, 0, 8346, 8305,
		1, 0, 0, 0, 8346, 8308, 1, 0, 0, 0, 8346, 8311, 1, 0, 0, 0, 8346, 8323,
		1, 0, 0, 0, 8347, 8366, 1, 0, 0, 0, 8348, 8349, 5, 110, 0, 0, 8349, 8350,
		5, 118, 0, 0, 8350, 8365, 3, 1060, 530, 0, 8351, 8353, 5, 121, 0, 0, 8352,
		8354, 3, 1070, 535, 0, 8353, 8352, 1, 0, 0, 0, 8353, 8354, 1, 0, 0, 0,
		8354, 8355, 1, 0, 0, 0, 8355, 8356, 5, 118, 0, 0, 8356, 8365, 3, 1060,
		530, 0, 8357, 8359, 3, 1070, 535, 0, 8358, 8357, 1, 0, 0, 0, 8358, 8359,
		1, 0, 0, 0, 8359, 8360, 1, 0, 0, 0, 8360, 8361, 5, 118, 0, 0, 8361, 8362,
		3, 1060, 530, 0, 8362, 8363, 3, 1072, 536, 0, 8363, 8365, 1, 0, 0, 0, 8364,
		8348, 1, 0, 0, 0, 8364, 8351, 1, 0, 0, 0, 8364, 8358, 1, 0, 0, 0, 8365,
		8368, 1, 0, 0, 0, 8366, 8364, 1, 0, 0, 0, 8366, 8367, 1, 0, 0, 0, 8367,
		1061, 1, 0, 0, 0, 8368, 8366, 1, 0, 0, 0, 8369, 8371, 5, 36, 0, 0, 8370,
		8369, 1, 0, 0, 0, 8370, 8371, 1, 0, 0, 0, 8371, 8372, 1, 0, 0, 0, 8372,
		8377, 3, 1372, 686, 0, 8373, 8374, 5, 2, 0, 0, 8374, 8375, 3, 1338, 669,
		0, 8375, 8376, 5, 3, 0, 0, 8376, 8378, 1, 0, 0, 0, 8377, 8373, 1, 0, 0,
		0, 8377, 8378, 1, 0, 0, 0, 8378, 1063, 1, 0, 0, 0, 8379, 8382, 3, 1066,
		533, 0, 8380, 8382, 1, 0, 0, 0, 8381, 8379, 1, 0, 0, 0, 8381, 8380, 1,
		0, 0, 0, 8382, 1065, 1, 0, 0, 0, 8383, 8385, 5, 36, 0, 0, 8384, 8383, 1,
		0, 0, 0, 8384, 8385, 1, 0, 0, 0, 8385, 8386, 1, 0, 0, 0, 8386, 8391, 3,
		1374, 687, 0, 8387, 8388, 5, 2, 0, 0, 8388, 8389, 3, 1338, 669, 0, 8389,
		8390, 5, 3, 0, 0, 8390, 8392, 1, 0, 0, 0, 8391, 8387, 1, 0, 0, 0, 8391,
		8392, 1, 0, 0, 0, 8392, 1067, 1, 0, 0, 0, 8393, 8407, 3, 1062, 531, 0,
		8394, 8396, 5, 36, 0, 0, 8395, 8397, 3, 1372, 686, 0, 8396, 8395, 1, 0,
		0, 0, 8396, 8397, 1, 0, 0, 0, 8397, 8400, 1, 0, 0, 0, 8398, 8400, 3, 1372,
		686, 0, 8399, 8394, 1, 0, 0, 0, 8399, 8398, 1, 0, 0, 0, 8400, 8401, 1,
		0, 0, 0, 8401, 8402, 5, 2, 0, 0, 8402, 8403, 3, 1100, 550, 0, 8403, 8404,
		5, 3, 0, 0, 8404, 8407, 1, 0, 0, 0, 8405, 8407, 1, 0, 0, 0, 8406, 8393,
		1, 0, 0, 0, 8406, 8399, 1, 0, 0, 0, 8406, 8405, 1, 0, 0, 0, 8407, 1069,
		1, 0, 0, 0, 8408, 8410, 7, 41, 0, 0, 8409, 8411, 5, 123, 0, 0, 8410, 8409,
		1, 0, 0, 0, 8410, 8411, 1, 0, 0, 0, 8411, 1071, 1, 0, 0, 0, 8412, 8413,
		5, 100, 0, 0, 8413, 8414, 5, 2, 0, 0, 8414, 8415, 3, 1338, 669, 0, 8415,
		8416, 5, 3, 0, 0, 8416, 8420, 1, 0, 0, 0, 8417, 8418, 5, 80, 0, 0, 8418,
		8420, 3, 1162, 581, 0, 8419, 8412, 1, 0, 0, 0, 8419, 8417, 1, 0, 0, 0,
		8420, 1073, 1, 0, 0, 0, 8421, 8423, 3, 1336, 668, 0, 8422, 8424, 5, 9,
		0, 0, 8423, 8422, 1, 0, 0, 0, 8423, 8424, 1, 0, 0, 0, 8424, 8434, 1, 0,
		0, 0, 8425, 8431, 5, 81, 0, 0, 8426, 8432, 3, 1336, 668, 0, 8427, 8428,
		5, 2, 0, 0, 8428, 8429, 3, 1336, 668, 0, 8429, 8430, 5, 3, 0, 0, 8430,
		8432, 1, 0, 0, 0, 8431, 8426, 1, 0, 0, 0, 8431, 8427, 1, 0, 0, 0, 8432,
		8434, 1, 0, 0, 0, 8433, 8421, 1, 0, 0, 0, 8433, 8425, 1, 0, 0, 0, 8434,
		1075, 1, 0, 0, 0, 8435, 8440, 3, 1074, 537, 0, 8436, 8437, 5, 6, 0, 0,
		8437, 8439, 3, 1074, 537, 0, 8438, 8436, 1, 0, 0, 0, 8439, 8442, 1, 0,
		0, 0, 8440, 8438, 1, 0, 0, 0, 8440, 8441, 1, 0, 0, 0, 8441, 1077, 1, 0,
		0, 0, 8442, 8440, 1, 0, 0, 0, 8443, 8448, 3, 1074, 537, 0, 8444, 8446,
		5, 36, 0, 0, 8445, 8444, 1, 0, 0, 0, 8445, 8446, 1, 0, 0, 0, 8446, 8447,
		1, 0, 0, 0, 8447, 8449, 3, 1372, 686, 0, 8448, 8445, 1, 0, 0, 0, 8448,
		8449, 1, 0, 0, 0, 8449, 1079, 1, 0, 0, 0, 8450, 8451, 5, 472, 0, 0, 8451,
		8452, 3, 1346, 673, 0, 8452, 8453, 5, 2, 0, 0, 8453, 8454, 3, 1280, 640,
		0, 8454, 8455, 5, 3, 0, 0, 8455, 8456, 3, 1082, 541, 0, 8456, 1081, 1,
		0, 0, 0, 8457, 8458, 5, 303, 0, 0, 8458, 8459, 5, 2, 0, 0, 8459, 8460,
		3, 1162, 581, 0, 8460, 8461, 5, 3, 0, 0, 8461, 8464, 1, 0, 0, 0, 8462,
		8464, 1, 0, 0, 0, 8463, 8457, 1, 0, 0, 0, 8463, 8462, 1, 0, 0, 0, 8464,
		1083, 1, 0, 0, 0, 8465, 8466, 3, 1214, 607, 0, 8466, 8467, 3, 1092, 546,
		0, 8467, 8476, 1, 0, 0, 0, 8468, 8469, 5, 313, 0, 0, 8469, 8470, 5, 64,
		0, 0, 8470, 8471, 5, 2, 0, 0, 8471, 8472, 3, 1088, 544, 0, 8472, 8473,
		5, 3, 0, 0, 8473, 8474, 3, 1092, 546, 0, 8474, 8476, 1, 0, 0, 0, 8475,
		8465, 1, 0, 0, 0, 8475, 8468, 1, 0, 0, 0, 8476, 1085, 1, 0, 0, 0, 8477,
		8478, 3, 1214, 607, 0, 8478, 8479, 3, 1090, 545, 0, 8479, 1087, 1, 0, 0,
		0, 8480, 8485, 3, 1086, 543, 0, 8481, 8482, 5, 6, 0, 0, 8482, 8484, 3,
		1086, 543, 0, 8483, 8481, 1, 0, 0, 0, 8484, 8487, 1, 0, 0, 0, 8485, 8483,
		1, 0, 0, 0, 8485, 8486, 1, 0, 0, 0, 8486, 1089, 1, 0, 0, 0, 8487, 8485,
		1, 0, 0, 0, 8488, 8489, 5, 36, 0, 0, 8489, 8490, 5, 2, 0, 0, 8490, 8491,
		3, 1100, 550, 0, 8491, 8492, 5, 3, 0, 0, 8492, 8495, 1, 0, 0, 0, 8493,
		8495, 1, 0, 0, 0, 8494, 8488, 1, 0, 0, 0, 8494, 8493, 1, 0, 0, 0, 8495,
		1091, 1, 0, 0, 0, 8496, 8497, 5, 105, 0, 0, 8497, 8500, 5, 473, 0, 0, 8498,
		8500, 1, 0, 0, 0, 8499, 8496, 1, 0, 0, 0, 8499, 8498, 1, 0, 0, 0, 8500,
		1093, 1, 0, 0, 0, 8501, 8502, 5, 103, 0, 0, 8502, 8505, 3, 1162, 581, 0,
		8503, 8505, 1, 0, 0, 0, 8504, 8501, 1, 0, 0, 0, 8504, 8503, 1, 0, 0, 0,
		8505, 1095, 1, 0, 0, 0, 8506, 8511, 5, 103, 0, 0, 8507, 8508, 5, 434, 0,
		0, 8508, 8509, 5, 268, 0, 0, 8509, 8512, 3, 954, 477, 0, 8510, 8512, 3,
		1162, 581, 0, 8511, 8507, 1, 0, 0, 0, 8511, 8510, 1, 0, 0, 0, 8512, 8515,
		1, 0, 0, 0, 8513, 8515, 1, 0, 0, 0, 8514, 8506, 1, 0, 0, 0, 8514, 8513,
		1, 0, 0, 0, 8515, 1097, 1, 0, 0, 0, 8516, 8519, 3, 1100, 550, 0, 8517,
		8519, 1, 0, 0, 0, 8518, 8516, 1, 0, 0, 0, 8518, 8517, 1, 0, 0, 0, 8519,
		1099, 1, 0, 0, 0, 8520, 8525, 3, 1102, 551, 0, 8521, 8522, 5, 6, 0, 0,
		8522, 8524, 3, 1102, 551, 0, 8523, 8521, 1, 0, 0, 0, 8524, 8527, 1, 0,
		0, 0, 8525, 8523, 1, 0, 0, 0, 8525, 8526, 1, 0, 0, 0, 8526, 1101, 1, 0,
		0, 0, 8527, 8525, 1, 0, 0, 0, 8528, 8529, 3, 1372, 686, 0, 8529, 8530,
		3, 1118, 559, 0, 8530, 8531, 3, 110, 55, 0, 8531, 1103, 1, 0, 0, 0, 8532,
		8533, 5, 474, 0, 0, 8533, 8549, 5, 2, 0, 0, 8534, 8535, 3, 1206, 603, 0,
		8535, 8536, 3, 1232, 616, 0, 8536, 8537, 5, 475, 0, 0, 8537, 8538, 3, 1106,
		553, 0, 8538, 8550, 1, 0, 0, 0, 8539, 8540, 5, 476, 0, 0, 8540, 8541, 5,
		2, 0, 0, 8541, 8542, 3, 1114, 557, 0, 8542, 8543, 5, 3, 0, 0, 8543, 8544,
		5, 6, 0, 0, 8544, 8545, 3, 1206, 603, 0, 8545, 8546, 3, 1232, 616, 0, 8546,
		8547, 5, 475, 0, 0, 8547, 8548, 3, 1106, 553, 0, 8548, 8550, 1, 0, 0, 0,
		8549, 8534, 1, 0, 0, 0, 8549, 8539, 1, 0, 0, 0, 8550, 8551, 1, 0, 0, 0,
		8551, 8552, 5, 3, 0, 0, 8552, 1105, 1, 0, 0, 0, 8553, 8558, 3, 1108, 554,
		0, 8554, 8555, 5, 6, 0, 0, 8555, 8557, 3, 1108, 554, 0, 8556, 8554, 1,
		0, 0, 0, 8557, 8560, 1, 0, 0, 0, 8558, 8556, 1, 0, 0, 0, 8558, 8559, 1,
		0, 0, 0, 8559, 1107, 1, 0, 0, 0, 8560, 8558, 1, 0, 0, 0, 8561, 8568, 3,
		1372, 686, 0, 8562, 8564, 3, 1118, 559, 0, 8563, 8565, 3, 1110, 555, 0,
		8564, 8563, 1, 0, 0, 0, 8564, 8565, 1, 0, 0, 0, 8565, 8569, 1, 0, 0, 0,
		8566, 8567, 5, 62, 0, 0, 8567, 8569, 5, 473, 0, 0, 8568, 8562, 1, 0, 0,
		0, 8568, 8566, 1, 0, 0, 0, 8569, 1109, 1, 0, 0, 0, 8570, 8572, 3, 1112,
		556, 0, 8571, 8570, 1, 0, 0, 0, 8572, 8573, 1, 0, 0, 0, 8573, 8571, 1,
		0, 0, 0, 8573, 8574, 1, 0, 0, 0, 8574, 1111, 1, 0, 0, 0, 8575, 8576, 5,
		53, 0, 0, 8576, 8584, 3, 1162, 581, 0, 8577, 8578, 3, 1382, 691, 0, 8578,
		8579, 3, 1162, 581, 0, 8579, 8584, 1, 0, 0, 0, 8580, 8581, 5, 77, 0, 0,
		8581, 8584, 5, 78, 0, 0, 8582, 8584, 5, 78, 0, 0, 8583, 8575, 1, 0, 0,
		0, 8583, 8577, 1, 0, 0, 0, 8583, 8580, 1, 0, 0, 0, 8583, 8582, 1, 0, 0,
		0, 8584, 1113, 1, 0, 0, 0, 8585, 8590, 3, 1116, 558, 0, 8586, 8587, 5,
		6, 0, 0, 8587, 8589, 3, 1116, 558, 0, 8588, 8586, 1, 0, 0, 0, 8589, 8592,
		1, 0, 0, 0, 8590, 8588, 1, 0, 0, 0, 8590, 8591, 1, 0, 0, 0, 8591, 1115,
		1, 0, 0, 0, 8592, 8590, 1, 0, 0, 0, 8593, 8594, 3, 1204, 602, 0, 8594,
		8595, 5, 36, 0, 0, 8595, 8596, 3, 1380, 690, 0, 8596, 8600, 1, 0, 0, 0,
		8597, 8598, 5, 53, 0, 0, 8598, 8600, 3, 1204, 602, 0, 8599, 8593, 1, 0,
		0, 0, 8599, 8597, 1, 0, 0, 0, 8600, 1117, 1, 0, 0, 0, 8601, 8603, 5, 408,
		0, 0, 8602, 8601, 1, 0, 0, 0, 8602, 8603, 1, 0, 0, 0, 8603, 8604, 1, 0,
		0, 0, 8604, 8613, 3, 1122, 561, 0, 8605, 8614, 3, 1120, 560, 0, 8606, 8611,
		5, 35, 0, 0, 8607, 8608, 5, 4, 0, 0, 8608, 8609, 3, 1356, 678, 0, 8609,
		8610, 5, 5, 0, 0, 8610, 8612, 1, 0, 0, 0, 8611, 8607, 1, 0, 0, 0, 8611,
		8612, 1, 0, 0, 0, 8612, 8614, 1, 0, 0, 0, 8613, 8605, 1, 0, 0, 0, 8613,
		8606, 1, 0, 0, 0, 8614, 8620, 1, 0, 0, 0, 8615, 8616, 3, 1336, 668, 0,
		8616, 8617, 5, 27, 0, 0, 8617, 8618, 7, 42, 0, 0, 8618, 8620, 1, 0, 0,
		0, 8619, 8602, 1, 0, 0, 0, 8619, 8615, 1, 0, 0, 0, 8620, 1119, 1, 0, 0,
		0, 8621, 8623, 5, 4, 0, 0, 8622, 8624, 3, 1356, 678, 0, 8623, 8622, 1,
		0, 0, 0, 8623, 8624, 1, 0, 0, 0, 8624, 8625, 1, 0, 0, 0, 8625, 8627, 5,
		5, 0, 0, 8626, 8621, 1, 0, 0, 0, 8627, 8630, 1, 0, 0, 0, 8628, 8626, 1,
		0, 0, 0, 8628, 8629, 1, 0, 0, 0, 8629, 1121, 1, 0, 0, 0, 8630, 8628, 1,
		0, 0, 0, 8631, 8645, 3, 1126, 563, 0, 8632, 8645, 3, 1130, 565, 0, 8633,
		8645, 3, 1134, 567, 0, 8634, 8645, 3, 1142, 571, 0, 8635, 8645, 3, 1150,
		575, 0, 8636, 8642, 3, 1152, 576, 0, 8637, 8643, 3, 1156, 578, 0, 8638,
		8639, 5, 2, 0, 0, 8639, 8640, 3, 1356, 678, 0, 8640, 8641, 5, 3, 0, 0,
		8641, 8643, 1, 0, 0, 0, 8642, 8637, 1, 0, 0, 0, 8642, 8638, 1, 0, 0, 0,
		8643, 8645, 1, 0, 0, 0, 8644, 8631, 1, 0, 0, 0, 8644, 8632, 1, 0, 0, 0,
		8644, 8633, 1, 0, 0, 0, 8644, 8634, 1, 0, 0, 0, 8644, 8635, 1, 0, 0, 0,
		8644, 8636, 1, 0, 0, 0, 8645, 1123, 1, 0, 0, 0, 8646, 8651, 3, 1130, 565,
		0, 8647, 8651, 3, 1136, 568, 0, 8648, 8651, 3, 1144, 572, 0, 8649, 8651,
		3, 1150, 575, 0, 8650, 8646, 1, 0, 0, 0, 8650, 8647, 1, 0, 0, 0, 8650,
		8648, 1, 0, 0, 0, 8650, 8649, 1, 0, 0, 0, 8651, 1125, 1, 0, 0, 0, 8652,
		8657, 3, 1394, 697, 0, 8653, 8657, 3, 1376, 688, 0, 8654, 8657, 5, 119,
		0, 0, 8655, 8657, 5, 126, 0, 0, 8656, 8652, 1, 0, 0, 0, 8656, 8653, 1,
		0, 0, 0, 8656, 8654, 1, 0, 0, 0, 8656, 8655, 1, 0, 0, 0, 8657, 8659, 1,
		0, 0, 0, 8658, 8660, 3, 526, 263, 0, 8659, 8658, 1, 0, 0, 0, 8659, 8660,
		1, 0, 0, 0, 8660, 8661, 1, 0, 0, 0, 8661, 8662, 3, 1128, 564, 0, 8662,
		1127, 1, 0, 0, 0, 8663, 8664, 5, 2, 0, 0, 8664, 8665, 3, 1280, 640, 0,
		8665, 8666, 5, 3, 0, 0, 8666, 8669, 1, 0, 0, 0, 8667, 8669, 1, 0, 0, 0,
		8668, 8663, 1, 0, 0, 0, 8668, 8667, 1, 0, 0, 0, 8669, 1129, 1, 0, 0, 0,
		8670, 8687, 5, 394, 0, 0, 8671, 8687, 5, 395, 0, 0, 8672, 8687, 5, 409,
		0, 0, 8673, 8687, 5, 381, 0, 0, 8674, 8687, 5, 406, 0, 0, 8675, 8676, 5,
		391, 0, 0, 8676, 8687, 3, 1132, 566, 0, 8677, 8678, 5, 190, 0, 0, 8678,
		8687, 5, 405, 0, 0, 8679, 8680, 5, 388, 0, 0, 8680, 8687, 3, 1128, 564,
		0, 8681, 8682, 5, 387, 0, 0, 8682, 8687, 3, 1128, 564, 0, 8683, 8684, 5,
		402, 0, 0, 8684, 8687, 3, 1128, 564, 0, 8685, 8687, 5, 383, 0, 0, 8686,
		8670, 1, 0, 0, 0, 8686, 8671, 1, 0, 0, 0, 8686, 8672, 1, 0, 0, 0, 8686,
		8673, 1, 0, 0, 0, 8686, 8674, 1, 0, 0, 0, 8686, 8675, 1, 0, 0, 0, 8686,
		8677, 1, 0, 0, 0, 8686, 8679, 1, 0, 0, 0, 8686, 8681, 1, 0, 0, 0, 8686,
		8683, 1, 0, 0, 0, 8686, 8685, 1, 0, 0, 0, 8687, 1131, 1, 0, 0, 0, 8688,
		8689, 5, 2, 0, 0, 8689, 8690, 3, 1356, 678, 0, 8690, 8691, 5, 3, 0, 0,
		8691, 8694, 1, 0, 0, 0, 8692, 8694, 1, 0, 0, 0, 8693, 8688, 1, 0, 0, 0,
		8693, 8692, 1, 0, 0, 0, 8694, 1133, 1, 0, 0, 0, 8695, 8698, 3, 1138, 569,
		0, 8696, 8698, 3, 1140, 570, 0, 8697, 8695, 1, 0, 0, 0, 8697, 8696, 1,
		0, 0, 0, 8698, 1135, 1, 0, 0, 0, 8699, 8702, 3, 1138, 569, 0, 8700, 8702,
		3, 1140, 570, 0, 8701, 8699, 1, 0, 0, 0, 8701, 8700, 1, 0, 0, 0, 8702,
		1137, 1, 0, 0, 0, 8703, 8704, 5, 382, 0, 0, 8704, 8705, 3, 1148, 574, 0,
		8705, 8706, 5, 2, 0, 0, 8706, 8707, 3, 1280, 640, 0, 8707, 8708, 5, 3,
		0, 0, 8708, 1139, 1, 0, 0, 0, 8709, 8710, 5, 382, 0, 0, 8710, 8711, 3,
		1148, 574, 0, 8711, 1141, 1, 0, 0, 0, 8712, 8717, 3, 1146, 573, 0, 8713,
		8714, 5, 2, 0, 0, 8714, 8715, 3, 1356, 678, 0, 8715, 8716, 5, 3, 0, 0,
		8716, 8718, 1, 0, 0, 0, 8717, 8713, 1, 0, 0, 0, 8717, 8718, 1, 0, 0, 0,
		8718, 1143, 1, 0, 0, 0, 8719, 8724, 3, 1146, 573, 0, 8720, 8721, 5, 2,
		0, 0, 8721, 8722, 3, 1356, 678, 0, 8722, 8723, 5, 3, 0, 0, 8723, 8725,
		1, 0, 0, 0, 8724, 8720, 1, 0, 0, 0, 8724, 8725, 1, 0, 0, 0, 8725, 1145,
		1, 0, 0, 0, 8726, 8727, 7, 43, 0, 0, 8727, 8733, 3, 1148, 574, 0, 8728,
		8733, 5, 416, 0, 0, 8729, 8730, 5, 398, 0, 0, 8730, 8731, 7, 44, 0, 0,
		8731, 8733, 3, 1148, 574, 0, 8732, 8726, 1, 0, 0, 0, 8732, 8728, 1, 0,
		0, 0, 8732, 8729, 1, 0, 0, 0, 8733, 1147, 1, 0, 0, 0, 8734, 8737, 5, 367,
		0, 0, 8735, 8737, 1, 0, 0, 0, 8736, 8734, 1, 0, 0, 0, 8736, 8735, 1, 0,
		0, 0, 8737, 1149, 1, 0, 0, 0, 8738, 8743, 7, 45, 0, 0, 8739, 8740, 5, 2,
		0, 0, 8740, 8741, 3, 1356, 678, 0, 8741, 8742, 5, 3, 0, 0, 8742, 8744,
		1, 0, 0, 0, 8743, 8739, 1, 0, 0, 0, 8743, 8744, 1, 0, 0, 0, 8744, 8745,
		1, 0, 0, 0, 8745, 8746, 3, 1154, 577, 0, 8746, 1151, 1, 0, 0, 0, 8747,
		8748, 5, 396, 0, 0, 8748, 1153, 1, 0, 0, 0, 8749, 8750, 5, 105, 0, 0, 8750,
		8751, 5, 411, 0, 0, 8751, 8757, 5, 379, 0, 0, 8752, 8753, 5, 372, 0, 0,
		8753, 8754, 5, 411, 0, 0, 8754, 8757, 5, 379, 0, 0, 8755, 8757, 1, 0, 0,
		0, 8756, 8749, 1, 0, 0, 0, 8756, 8752, 1, 0, 0, 0, 8756, 8755, 1, 0, 0,
		0, 8757, 1155, 1, 0, 0, 0, 8758, 8785, 5, 377, 0, 0, 8759, 8785, 5, 257,
		0, 0, 8760, 8785, 5, 176, 0, 0, 8761, 8785, 5, 218, 0, 0, 8762, 8785, 5,
		254, 0, 0, 8763, 8785, 3, 1158, 579, 0, 8764, 8765, 5, 377, 0, 0, 8765,
		8766, 5, 94, 0, 0, 8766, 8785, 5, 257, 0, 0, 8767, 8768, 5, 176, 0, 0,
		8768, 8772, 5, 94, 0, 0, 8769, 8773, 5, 218, 0, 0, 8770, 8773, 5, 254,
		0, 0, 8771, 8773, 3, 1158, 579, 0, 8772, 8769, 1, 0, 0, 0, 8772, 8770,
		1, 0, 0, 0, 8772, 8771, 1, 0, 0, 0, 8773, 8785, 1, 0, 0, 0, 8774, 8775,
		5, 218, 0, 0, 8775, 8778, 5, 94, 0, 0, 8776, 8779, 5, 254, 0, 0, 8777,
		8779, 3, 1158, 579, 0, 8778, 8776, 1, 0, 0, 0, 8778, 8777, 1, 0, 0, 0,
		8779, 8785, 1, 0, 0, 0, 8780, 8781, 5, 254, 0, 0, 8781, 8782, 5, 94, 0,
		0, 8782, 8785, 3, 1158, 579, 0, 8783, 8785, 1, 0, 0, 0, 8784, 8758, 1,
		0, 0, 0, 8784, 8759, 1, 0, 0, 0, 8784, 8760, 1, 0, 0, 0, 8784, 8761, 1,
		0, 0, 0, 8784, 8762, 1, 0, 0, 0, 8784, 8763, 1, 0, 0, 0, 8784, 8764, 1,
		0, 0, 0, 8784, 8767, 1, 0, 0, 0, 8784, 8774, 1, 0, 0, 0, 8784, 8780, 1,
		0, 0, 0, 8784, 8783, 1, 0, 0, 0, 8785, 1157, 1, 0, 0, 0, 8786, 8791, 5,
		319, 0, 0, 8787, 8788, 5, 2, 0, 0, 8788, 8789, 3, 1356, 678, 0, 8789, 8790,
		5, 3, 0, 0, 8790, 8792, 1, 0, 0, 0, 8791, 8787, 1, 0, 0, 0, 8791, 8792,
		1, 0, 0, 0, 8792, 1159, 1, 0, 0, 0, 8793, 8794, 5, 197, 0, 0, 8794, 8797,
		3, 1162, 581, 0, 8795, 8797, 1, 0, 0, 0, 8796, 8793, 1, 0, 0, 0, 8796,
		8795, 1, 0, 0, 0, 8797, 1161, 1, 0, 0, 0, 8798, 8799, 3, 1164, 582, 0,
		8799, 1163, 1, 0, 0, 0, 8800, 8802, 3, 1166, 583, 0, 8801, 8803, 3, 1274,
		637, 0, 8802, 8801, 1, 0, 0, 0, 8802, 8803, 1, 0, 0, 0, 8803, 1165, 1,
		0, 0, 0, 8804, 8809, 3, 1168, 584, 0, 8805, 8806, 7, 46, 0, 0, 8806, 8808,
		3, 1168, 584, 0, 8807, 8805, 1, 0, 0, 0, 8808, 8811, 1, 0, 0, 0, 8809,
		8807, 1, 0, 0, 0, 8809, 8810, 1, 0, 0, 0, 8810, 1167, 1, 0, 0, 0, 8811,
		8809, 1, 0, 0, 0, 8812, 8817, 3, 1170, 585, 0, 8813, 8814, 5, 82, 0, 0,
		8814, 8816, 3, 1170, 585, 0, 8815, 8813, 1, 0, 0, 0, 8816, 8819, 1, 0,
		0, 0, 8817, 8815, 1, 0, 0, 0, 8817, 8818, 1, 0, 0, 0, 8818, 1169, 1, 0,
		0, 0, 8819, 8817, 1, 0, 0, 0, 8820, 8825, 3, 1172, 586, 0, 8821, 8822,
		5, 33, 0, 0, 8822, 8824, 3, 1172, 586, 0, 8823, 8821, 1, 0, 0, 0, 8824,
		8827, 1, 0, 0, 0, 8825, 8823, 1, 0, 0, 0, 8825, 8826, 1, 0, 0, 0, 8826,
		1171, 1, 0, 0, 0, 8827, 8825, 1, 0, 0, 0, 8828, 8840, 3, 1174, 587, 0,
		8829, 8831, 5, 77, 0, 0, 8830, 8829, 1, 0, 0, 0, 8830, 8831, 1, 0, 0, 0,
		8831, 8832, 1, 0, 0, 0, 8832, 8834, 5, 380, 0, 0, 8833, 8835, 5, 91, 0,
		0, 8834, 8833, 1, 0, 0, 0, 8834, 8835, 1, 0, 0, 0, 8835, 8836, 1, 0, 0,
		0, 8836, 8837, 3, 1174, 587, 0, 8837, 8838, 5, 33, 0, 0, 8838, 8839, 3,
		1174, 587, 0, 8839, 8841, 1, 0, 0, 0, 8840, 8830, 1, 0, 0, 0, 8840, 8841,
		1, 0, 0, 0, 8841, 1173, 1, 0, 0, 0, 8842, 8848, 3, 1176, 588, 0, 8843,
		8845, 5, 77, 0, 0, 8844, 8843, 1, 0, 0, 0, 8844, 8845, 1, 0, 0, 0, 8845,
		8846, 1, 0, 0, 0, 8846, 8847, 5, 68, 0, 0, 8847, 8849, 3, 1306, 653, 0,
		8848, 8844, 1, 0, 0, 0, 8848, 8849, 1, 0, 0, 0, 8849, 1175, 1, 0, 0, 0,
		8850, 8852, 5, 77, 0, 0, 8851, 8850, 1, 0, 0, 0, 8851, 8852, 1, 0, 0, 0,
		8852, 8853, 1, 0, 0, 0, 8853, 8854, 3, 1178, 589, 0, 8854, 1177, 1, 0,
		0, 0, 8855, 8857, 3, 1180, 590, 0, 8856, 8858, 7, 47, 0, 0, 8857, 8856,
		1, 0, 0, 0, 8857, 8858, 1, 0, 0, 0, 8858, 1179, 1, 0, 0, 0, 8859, 8883,
		3, 1182, 591, 0, 8860, 8862, 5, 116, 0, 0, 8861, 8863, 5, 77, 0, 0, 8862,
		8861, 1, 0, 0, 0, 8862, 8863, 1, 0, 0, 0, 8863, 8881, 1, 0, 0, 0, 8864,
		8882, 5, 78, 0, 0, 8865, 8882, 5, 96, 0, 0, 8866, 8882, 5, 60, 0, 0, 8867,
		8882, 5, 358, 0, 0, 8868, 8869, 5, 56, 0, 0, 8869, 8870, 5, 64, 0, 0, 8870,
		8882, 3, 1162, 581, 0, 8871, 8872, 5, 268, 0, 0, 8872, 8873, 5, 2, 0, 0,
		8873, 8874, 3, 1286, 643, 0, 8874, 8875, 5, 3, 0, 0, 8875, 8882, 1, 0,
		0, 0, 8876, 8882, 5, 188, 0, 0, 8877, 8879, 3, 1296, 648, 0, 8878, 8877,
		1, 0, 0, 0, 8878, 8879, 1, 0, 0, 0, 8879, 8880, 1, 0, 0, 0, 8880, 8882,
		5, 478, 0, 0, 8881, 8864, 1, 0, 0, 0, 8881, 8865, 1, 0, 0, 0, 8881, 8866,
		1, 0, 0, 0, 8881, 8867, 1, 0, 0, 0, 8881, 8868, 1, 0, 0, 0, 8881, 8871,
		1, 0, 0, 0, 8881, 8876, 1, 0, 0, 0, 8881, 8878, 1, 0, 0, 0, 8882, 8884,
		1, 0, 0, 0, 8883, 8860, 1, 0, 0, 0, 8883, 8884, 1, 0, 0, 0, 8884, 1181,
		1, 0, 0, 0, 8885, 8897, 3, 1184, 592, 0, 8886, 8887, 7, 48, 0, 0, 8887,
		8898, 3, 1184, 592, 0, 8888, 8889, 3, 1278, 639, 0, 8889, 8895, 3, 1268,
		634, 0, 8890, 8896, 3, 962, 481, 0, 8891, 8892, 5, 2, 0, 0, 8892, 8893,
		3, 1162, 581, 0, 8893, 8894, 5, 3, 0, 0, 8894, 8896, 1, 0, 0, 0, 8895,
		8890, 1, 0, 0, 0, 8895, 8891, 1, 0, 0, 0, 8896, 8898, 1, 0, 0, 0, 8897,
		8886, 1, 0, 0, 0, 8897, 8888, 1, 0, 0, 0, 8897, 8898, 1, 0, 0, 0, 8898,
		1183, 1, 0, 0, 0, 8899, 8912, 3, 1186, 593, 0, 8900, 8902, 5, 77, 0, 0,
		8901, 8900, 1, 0, 0, 0, 8901, 8902, 1, 0, 0, 0, 8902, 8907, 1, 0, 0, 0,
		8903, 8908, 5, 120, 0, 0, 8904, 8908, 5, 114, 0, 0, 8905, 8906, 5, 127,
		0, 0, 8906, 8908, 5, 94, 0, 0, 8907, 8903, 1, 0, 0, 0, 8907, 8904, 1, 0,
		0, 0, 8907, 8905, 1, 0, 0, 0, 8908, 8909, 1, 0, 0, 0, 8909, 8910, 3, 1186,
		593, 0, 8910, 8911, 3, 1160, 580, 0, 8911, 8913, 1, 0, 0, 0, 8912, 8901,
		1, 0, 0, 0, 8912, 8913, 1, 0, 0, 0, 8913, 1185, 1, 0, 0, 0, 8914, 8920,
		3, 1188, 594, 0, 8915, 8916, 3, 1274, 637, 0, 8916, 8917, 3, 1188, 594,
		0, 8917, 8919, 1, 0, 0, 0, 8918, 8915, 1, 0, 0, 0, 8919, 8922, 1, 0, 0,
		0, 8920, 8918, 1, 0, 0, 0, 8920, 8921, 1, 0, 0, 0, 8921, 1187, 1, 0, 0,
		0, 8922, 8920, 1, 0, 0, 0, 8923, 8925, 3, 1274, 637, 0, 8924, 8923, 1,
		0, 0, 0, 8924, 8925, 1, 0, 0, 0, 8925, 8926, 1, 0, 0, 0, 8926, 8927, 3,
		1190, 595, 0, 8927, 1189, 1, 0, 0, 0, 8928, 8933, 3, 1192, 596, 0, 8929,
		8930, 7, 49, 0, 0, 8930, 8932, 3, 1192, 596, 0, 8931, 8929, 1, 0, 0, 0,
		8932, 8935, 1, 0, 0, 0, 8933, 8931, 1, 0, 0, 0, 8933, 8934, 1, 0, 0, 0,
		8934, 1191, 1, 0, 0, 0, 8935, 8933, 1, 0, 0, 0, 8936, 8941, 3, 1194, 597,
		0, 8937, 8938, 7, 50, 0, 0, 8938, 8940, 3, 1194, 597, 0, 8939, 8937, 1,
		0, 0, 0, 8940, 8943, 1, 0, 0, 0, 8941, 8939, 1, 0, 0, 0, 8941, 8942, 1,
		0, 0, 0, 8942, 1193, 1, 0, 0, 0, 8943, 8941, 1, 0, 0, 0, 8944, 8947, 3,
		1196, 598, 0, 8945, 8946, 5, 15, 0, 0, 8946, 8948, 3, 1162, 581, 0, 8947,
		8945, 1, 0, 0, 0, 8947, 8948, 1, 0, 0, 0, 8948, 1195, 1, 0, 0, 0, 8949,
		8951, 7, 49, 0, 0, 8950, 8949, 1, 0, 0, 0, 8950, 8951, 1, 0, 0, 0, 8951,
		8952, 1, 0, 0, 0, 8952, 8953, 3, 1198, 599, 0, 8953, 1197, 1, 0, 0, 0,
		8954, 8959, 3, 1200, 600, 0, 8955, 8956, 5, 142, 0, 0, 8956, 8957, 5, 411,
		0, 0, 8957, 8958, 5, 379, 0, 0, 8958, 8960, 3, 1162, 581, 0, 8959, 8955,
		1, 0, 0, 0, 8959, 8960, 1, 0, 0, 0, 8960, 1199, 1, 0, 0, 0, 8961, 8964,
		3, 1202, 601, 0, 8962, 8963, 5, 43, 0, 0, 8963, 8965, 3, 524, 262, 0, 8964,
		8962, 1, 0, 0, 0, 8964, 8965, 1, 0, 0, 0, 8965, 1201, 1, 0, 0, 0, 8966,
		8971, 3, 1206, 603, 0, 8967, 8968, 5, 26, 0, 0, 8968, 8970, 3, 1118, 559,
		0, 8969, 8967, 1, 0, 0, 0, 8970, 8973, 1, 0, 0, 0, 8971, 8969, 1, 0, 0,
		0, 8971, 8972, 1, 0, 0, 0, 8972, 1203, 1, 0, 0, 0, 8973, 8971, 1, 0, 0,
		0, 8974, 8975, 6, 602, -1, 0, 8975, 8982, 3, 1206, 603, 0, 8976, 8977,
		7, 49, 0, 0, 8977, 8982, 3, 1204, 602, 9, 8978, 8979, 3, 1274, 637, 0,
		8979, 8980, 3, 1204, 602, 3, 8980, 8982, 1, 0, 0, 0, 8981, 8974, 1, 0,
		0, 0, 8981, 8976, 1, 0, 0, 0, 8981, 8978, 1, 0, 0, 0, 8982, 9022, 1, 0,
		0, 0, 8983, 8984, 10, 8, 0, 0, 8984, 8985, 5, 15, 0, 0, 8985, 9021, 3,
		1204, 602, 9, 8986, 8987, 10, 7, 0, 0, 8987, 8988, 7, 50, 0, 0, 8988, 9021,
		3, 1204, 602, 8, 8989, 8990, 10, 6, 0, 0, 8990, 8991, 7, 49, 0, 0, 8991,
		9021, 3, 1204, 602, 7, 8992, 8993, 10, 5, 0, 0, 8993, 8994, 3, 1274, 637,
		0, 8994, 8995, 3, 1204, 602, 6, 8995, 9021, 1, 0, 0, 0, 8996, 8997, 10,
		4, 0, 0, 8997, 8998, 7, 48, 0, 0, 8998, 9021, 3, 1204, 602, 5, 8999, 9000,
		10, 10, 0, 0, 9000, 9001, 5, 26, 0, 0, 9001, 9021, 3, 1118, 559, 0, 9002,
		9003, 10, 2, 0, 0, 9003, 9021, 3, 1274, 637, 0, 9004, 9005, 10, 1, 0, 0,
		9005, 9007, 5, 116, 0, 0, 9006, 9008, 5, 77, 0, 0, 9007, 9006, 1, 0, 0,
		0, 9007, 9008, 1, 0, 0, 0, 9008, 9018, 1, 0, 0, 0, 9009, 9010, 5, 56, 0,
		0, 9010, 9011, 5, 64, 0, 0, 9011, 9019, 3, 1204, 602, 0, 9012, 9013, 5,
		268, 0, 0, 9013, 9014, 5, 2, 0, 0, 9014, 9015, 3, 1286, 643, 0, 9015, 9016,
		5, 3, 0, 0, 9016, 9019, 1, 0, 0, 0, 9017, 9019, 5, 188, 0, 0, 9018, 9009,
		1, 0, 0, 0, 9018, 9012, 1, 0, 0, 0, 9018, 9017, 1, 0, 0, 0, 9019, 9021,
		1, 0, 0, 0, 9020, 8983, 1, 0, 0, 0, 9020, 8986, 1, 0, 0, 0, 9020, 8989,
		1, 0, 0, 0, 9020, 8992, 1, 0, 0, 0, 9020, 8996, 1, 0, 0, 0, 9020, 8999,
		1, 0, 0, 0, 9020, 9002, 1, 0, 0, 0, 9020, 9004, 1, 0, 0, 0, 9021, 9024,
		1, 0, 0, 0, 9022, 9020, 1, 0, 0, 0, 9022, 9023, 1, 0, 0, 0, 9023, 1205,
		1, 0, 0, 0, 9024, 9022, 1, 0, 0, 0, 9025, 9026, 5, 389, 0, 0, 9026, 9062,
		3, 962, 481, 0, 9027, 9030, 5, 35, 0, 0, 9028, 9031, 3, 962, 481, 0, 9029,
		9031, 3, 1288, 644, 0, 9030, 9028, 1, 0, 0, 0, 9030, 9029, 1, 0, 0, 0,
		9031, 9062, 1, 0, 0, 0, 9032, 9033, 5, 28, 0, 0, 9033, 9062, 3, 1326, 663,
		0, 9034, 9035, 5, 470, 0, 0, 9035, 9036, 5, 2, 0, 0, 9036, 9037, 3, 1280,
		640, 0, 9037, 9038, 5, 3, 0, 0, 9038, 9062, 1, 0, 0, 0, 9039, 9040, 5,
		98, 0, 0, 9040, 9062, 3, 962, 481, 0, 9041, 9062, 3, 1318, 659, 0, 9042,
		9062, 3, 1348, 674, 0, 9043, 9062, 3, 1208, 604, 0, 9044, 9045, 5, 2, 0,
		0, 9045, 9046, 3, 1162, 581, 0, 9046, 9047, 5, 3, 0, 0, 9047, 9048, 3,
		1326, 663, 0, 9048, 9062, 1, 0, 0, 0, 9049, 9062, 3, 1308, 654, 0, 9050,
		9062, 3, 1212, 606, 0, 9051, 9053, 3, 962, 481, 0, 9052, 9054, 3, 1324,
		662, 0, 9053, 9052, 1, 0, 0, 0, 9053, 9054, 1, 0, 0, 0, 9054, 9062, 1,
		0, 0, 0, 9055, 9062, 3, 1264, 632, 0, 9056, 9062, 3, 1266, 633, 0, 9057,
		9058, 3, 1262, 631, 0, 9058, 9059, 5, 125, 0, 0, 9059, 9060, 3, 1262, 631,
		0, 9060, 9062, 1, 0, 0, 0, 9061, 9025, 1, 0, 0, 0, 9061, 9027, 1, 0, 0,
		0, 9061, 9032, 1, 0, 0, 0, 9061, 9034, 1, 0, 0, 0, 9061, 9039, 1, 0, 0,
		0, 9061, 9041, 1, 0, 0, 0, 9061, 9042, 1, 0, 0, 0, 9061, 9043, 1, 0, 0,
		0, 9061, 9044, 1, 0, 0, 0, 9061, 9049, 1, 0, 0, 0, 9061, 9050, 1, 0, 0,
		0, 9061, 9051, 1, 0, 0, 0, 9061, 9055, 1, 0, 0, 0, 9061, 9056, 1, 0, 0,
		0, 9061, 9057, 1, 0, 0, 0, 9062, 1207, 1, 0, 0, 0, 9063, 9064, 5, 661,
		0, 0, 9064, 1209, 1, 0, 0, 0, 9065, 9066, 3, 1346, 673, 0, 9066, 9085,
		5, 2, 0, 0, 9067, 9071, 3, 1282, 641, 0, 9068, 9069, 5, 6, 0, 0, 9069,
		9070, 5, 101, 0, 0, 9070, 9072, 3, 1284, 642, 0, 9071, 9068, 1, 0, 0, 0,
		9071, 9072, 1, 0, 0, 0, 9072, 9073, 1, 0, 0, 0, 9073, 9074, 3, 996, 498,
		0, 9074, 9086, 1, 0, 0, 0, 9075, 9076, 5, 101, 0, 0, 9076, 9077, 3, 1284,
		642, 0, 9077, 9078, 3, 996, 498, 0, 9078, 9086, 1, 0, 0, 0, 9079, 9080,
		7, 51, 0, 0, 9080, 9081, 3, 1282, 641, 0, 9081, 9082, 3, 996, 498, 0, 9082,
		9086, 1, 0, 0, 0, 9083, 9086, 5, 9, 0, 0, 9084, 9086, 1, 0, 0, 0, 9085,
		9067, 1, 0, 0, 0, 9085, 9075, 1, 0, 0, 0, 9085, 9079, 1, 0, 0, 0, 9085,
		9083, 1, 0, 0, 0, 9085, 9084, 1, 0, 0, 0, 9086, 9087, 1, 0, 0, 0, 9087,
		9088, 5, 3, 0, 0, 9088, 1211, 1, 0, 0, 0, 9089, 9090, 3, 1210, 605, 0,
		9090, 9091, 3, 1236, 618, 0, 9091, 9092, 3, 1238, 619, 0, 9092, 9093, 3,
		1246, 623, 0, 9093, 9096, 1, 0, 0, 0, 9094, 9096, 3, 1216, 608, 0, 9095,
		9089, 1, 0, 0, 0, 9095, 9094, 1, 0, 0, 0, 9096, 1213, 1, 0, 0, 0, 9097,
		9100, 3, 1210, 605, 0, 9098, 9100, 3, 1216, 608, 0, 9099, 9097, 1, 0, 0,
		0, 9099, 9098, 1, 0, 0, 0, 9100, 1215, 1, 0, 0, 0, 9101, 9102, 5, 108,
		0, 0, 9102, 9103, 5, 62, 0, 0, 9103, 9104, 5, 2, 0, 0, 9104, 9105, 3, 1162,
		581, 0, 9105, 9106, 5, 3, 0, 0, 9106, 9279, 1, 0, 0, 0, 9107, 9279, 5,
		48, 0, 0, 9108, 9113, 5, 50, 0, 0, 9109, 9110, 5, 2, 0, 0, 9110, 9111,
		3, 1356, 678, 0, 9111, 9112, 5, 3, 0, 0, 9112, 9114, 1, 0, 0, 0, 9113,
		9109, 1, 0, 0, 0, 9113, 9114, 1, 0, 0, 0, 9114, 9279, 1, 0, 0, 0, 9115,
		9120, 5, 51, 0, 0, 9116, 9117, 5, 2, 0, 0, 9117, 9118, 3, 1356, 678, 0,
		9118, 9119, 5, 3, 0, 0, 9119, 9121, 1, 0, 0, 0, 9120, 9116, 1, 0, 0, 0,
		9120, 9121, 1, 0, 0, 0, 9121, 9279, 1, 0, 0, 0, 9122, 9127, 5, 75, 0, 0,
		9123, 9124, 5, 2, 0, 0, 9124, 9125, 3, 1356, 678, 0, 9125, 9126, 5, 3,
		0, 0, 9126, 9128, 1, 0, 0, 0, 9127, 9123, 1, 0, 0, 0, 9127, 9128, 1, 0,
		0, 0, 9128, 9279, 1, 0, 0, 0, 9129, 9134, 5, 76, 0, 0, 9130, 9131, 5, 2,
		0, 0, 9131, 9132, 3, 1356, 678, 0, 9132, 9133, 5, 3, 0, 0, 9133, 9135,
		1, 0, 0, 0, 9134, 9130, 1, 0, 0, 0, 9134, 9135, 1, 0, 0, 0, 9135, 9279,
		1, 0, 0, 0, 9136, 9279, 5, 49, 0, 0, 9137, 9279, 5, 52, 0, 0, 9138, 9279,
		5, 89, 0, 0, 9139, 9279, 5, 99, 0, 0, 9140, 9279, 5, 47, 0, 0, 9141, 9279,
		5, 111, 0, 0, 9142, 9143, 5, 41, 0, 0, 9143, 9144, 5, 2, 0, 0, 9144, 9145,
		3, 1162, 581, 0, 9145, 9146, 5, 36, 0, 0, 9146, 9147, 3, 1118, 559, 0,
		9147, 9148, 5, 3, 0, 0, 9148, 9279, 1, 0, 0, 0, 9149, 9150, 5, 390, 0,
		0, 9150, 9151, 5, 2, 0, 0, 9151, 9152, 3, 1292, 646, 0, 9152, 9153, 5,
		3, 0, 0, 9153, 9279, 1, 0, 0, 0, 9154, 9155, 5, 489, 0, 0, 9155, 9156,
		5, 2, 0, 0, 9156, 9159, 3, 1162, 581, 0, 9157, 9158, 5, 6, 0, 0, 9158,
		9160, 3, 1296, 648, 0, 9159, 9157, 1, 0, 0, 0, 9159, 9160, 1, 0, 0, 0,
		9160, 9161, 1, 0, 0, 0, 9161, 9162, 5, 3, 0, 0, 9162, 9279, 1, 0, 0, 0,
		9163, 9164, 5, 403, 0, 0, 9164, 9165, 5, 2, 0, 0, 9165, 9166, 3, 1298,
		649, 0, 9166, 9167, 5, 3, 0, 0, 9167, 9279, 1, 0, 0, 0, 9168, 9169, 5,
		404, 0, 0, 9169, 9170, 5, 2, 0, 0, 9170, 9171, 3, 1300, 650, 0, 9171, 9172,
		5, 3, 0, 0, 9172, 9279, 1, 0, 0, 0, 9173, 9174, 5, 410, 0, 0, 9174, 9175,
		5, 2, 0, 0, 9175, 9176, 3, 1302, 651, 0, 9176, 9177, 5, 3, 0, 0, 9177,
		9279, 1, 0, 0, 0, 9178, 9179, 5, 413, 0, 0, 9179, 9180, 5, 2, 0, 0, 9180,
		9181, 3, 1162, 581, 0, 9181, 9182, 5, 36, 0, 0, 9182, 9183, 3, 1118, 559,
		0, 9183, 9184, 5, 3, 0, 0, 9184, 9279, 1, 0, 0, 0, 9185, 9186, 5, 414,
		0, 0, 9186, 9188, 5, 2, 0, 0, 9187, 9189, 7, 52, 0, 0, 9188, 9187, 1, 0,
		0, 0, 9188, 9189, 1, 0, 0, 0, 9189, 9190, 1, 0, 0, 0, 9190, 9191, 3, 1304,
		652, 0, 9191, 9192, 5, 3, 0, 0, 9192, 9279, 1, 0, 0, 0, 9193, 9194, 5,
		401, 0, 0, 9194, 9195, 5, 2, 0, 0, 9195, 9196, 3, 1162, 581, 0, 9196, 9197,
		5, 6, 0, 0, 9197, 9198, 3, 1162, 581, 0, 9198, 9199, 5, 3, 0, 0, 9199,
		9279, 1, 0, 0, 0, 9200, 9201, 5, 386, 0, 0, 9201, 9202, 5, 2, 0, 0, 9202,
		9203, 3, 1280, 640, 0, 9203, 9204, 5, 3, 0, 0, 9204, 9279, 1, 0, 0, 0,
		9205, 9206, 5, 392, 0, 0, 9206, 9207, 5, 2, 0, 0, 9207, 9208, 3, 1280,
		640, 0, 9208, 9209, 5, 3, 0, 0, 9209, 9279, 1, 0, 0, 0, 9210, 9211, 5,
		397, 0, 0, 9211, 9212, 5, 2, 0, 0, 9212, 9213, 3, 1280, 640, 0, 9213, 9214,
		5, 3, 0, 0, 9214, 9279, 1, 0, 0, 0, 9215, 9216, 5, 425, 0, 0, 9216, 9217,
		5, 2, 0, 0, 9217, 9218, 3, 1280, 640, 0, 9218, 9219, 5, 3, 0, 0, 9219,
		9279, 1, 0, 0, 0, 9220, 9221, 5, 426, 0, 0, 9221, 9222, 5, 2, 0, 0, 9222,
		9223, 5, 259, 0, 0, 9223, 9229, 3, 1380, 690, 0, 9224, 9227, 5, 6, 0, 0,
		9225, 9228, 3, 1222, 611, 0, 9226, 9228, 3, 1280, 640, 0, 9227, 9225, 1,
		0, 0, 0, 9227, 9226, 1, 0, 0, 0, 9228, 9230, 1, 0, 0, 0, 9229, 9224, 1,
		0, 0, 0, 9229, 9230, 1, 0, 0, 0, 9230, 9231, 1, 0, 0, 0, 9231, 9232, 5,
		3, 0, 0, 9232, 9279, 1, 0, 0, 0, 9233, 9234, 5, 427, 0, 0, 9234, 9235,
		5, 2, 0, 0, 9235, 9236, 3, 1206, 603, 0, 9236, 9237, 3, 1232, 616, 0, 9237,
		9238, 5, 3, 0, 0, 9238, 9279, 1, 0, 0, 0, 9239, 9240, 5, 428, 0, 0, 9240,
		9241, 5, 2, 0, 0, 9241, 9242, 3, 1224, 612, 0, 9242, 9243, 5, 3, 0, 0,
		9243, 9279, 1, 0, 0, 0, 9244, 9245, 5, 429, 0, 0, 9245, 9246, 5, 2, 0,
		0, 9246, 9247, 3, 1228, 614, 0, 9247, 9248, 3, 1162, 581, 0, 9248, 9249,
		3, 1230, 615, 0, 9249, 9250, 5, 3, 0, 0, 9250, 9279, 1, 0, 0, 0, 9251,
		9252, 5, 430, 0, 0, 9252, 9253, 5, 2, 0, 0, 9253, 9254, 5, 259, 0, 0, 9254,
		9257, 3, 1380, 690, 0, 9255, 9256, 5, 6, 0, 0, 9256, 9258, 3, 1162, 581,
		0, 9257, 9255, 1, 0, 0, 0, 9257, 9258, 1, 0, 0, 0, 9258, 9259, 1, 0, 0,
		0, 9259, 9260, 5, 3, 0, 0, 9260, 9279, 1, 0, 0, 0, 9261, 9262, 5, 431,
		0, 0, 9262, 9263, 5, 2, 0, 0, 9263, 9264, 5, 376, 0, 0, 9264, 9265, 3,
		1162, 581, 0, 9265, 9266, 5, 6, 0, 0, 9266, 9267, 3, 1218, 609, 0, 9267,
		9268, 3, 1220, 610, 0, 9268, 9269, 5, 3, 0, 0, 9269, 9279, 1, 0, 0, 0,
		9270, 9271, 5, 432, 0, 0, 9271, 9272, 5, 2, 0, 0, 9272, 9273, 3, 1228,
		614, 0, 9273, 9274, 3, 1162, 581, 0, 9274, 9275, 5, 36, 0, 0, 9275, 9276,
		3, 1122, 561, 0, 9276, 9277, 5, 3, 0, 0, 9277, 9279, 1, 0, 0, 0, 9278,
		9101, 1, 0, 0, 0, 9278, 9107, 1, 0, 0, 0, 9278, 9108, 1, 0, 0, 0, 9278,
		9115, 1, 0, 0, 0, 9278, 9122, 1, 0, 0, 0, 9278, 9129, 1, 0, 0, 0, 9278,
		9136, 1, 0, 0, 0, 9278, 9137, 1, 0, 0, 0, 9278, 9138, 1, 0, 0, 0, 9278,
		9139, 1, 0, 0, 0, 9278, 9140, 1, 0, 0, 0, 9278, 9141, 1, 0, 0, 0, 9278,
		9142, 1, 0, 0, 0, 9278, 9149, 1, 0, 0, 0, 9278, 9154, 1, 0, 0, 0, 9278,
		9163, 1, 0, 0, 0, 9278, 9168, 1, 0, 0, 0, 9278, 9173, 1, 0, 0, 0, 9278,
		9178, 1, 0, 0, 0, 9278, 9185, 1, 0, 0, 0, 9278, 9193, 1, 0, 0, 0, 9278,
		9200, 1, 0, 0, 0, 9278, 9205, 1, 0, 0, 0, 9278, 9210, 1, 0, 0, 0, 9278,
		9215, 1, 0, 0, 0, 9278, 9220, 1, 0, 0, 0, 9278, 9233, 1, 0, 0, 0, 9278,
		9239, 1, 0, 0, 0, 9278, 9244, 1, 0, 0, 0, 9278, 9251, 1, 0, 0, 0, 9278,
		9261, 1, 0, 0, 0, 9278, 9270, 1, 0, 0, 0, 9279, 1217, 1, 0, 0, 0, 9280,
		9281, 5, 368, 0, 0, 9281, 9286, 3, 1162, 581, 0, 9282, 9283, 5, 368, 0,
		0, 9283, 9284, 5, 262, 0, 0, 9284, 9286, 5, 450, 0, 0, 9285, 9280, 1, 0,
		0, 0, 9285, 9282, 1, 0, 0, 0, 9286, 1219, 1, 0, 0, 0, 9287, 9288, 5, 6,
		0, 0, 9288, 9289, 5, 332, 0, 0, 9289, 9299, 5, 378, 0, 0, 9290, 9291, 5,
		6, 0, 0, 9291, 9292, 5, 332, 0, 0, 9292, 9299, 5, 262, 0, 0, 9293, 9294,
		5, 6, 0, 0, 9294, 9295, 5, 332, 0, 0, 9295, 9296, 5, 262, 0, 0, 9296, 9299,
		5, 450, 0, 0, 9297, 9299, 1, 0, 0, 0, 9298, 9287, 1, 0, 0, 0, 9298, 9290,
		1, 0, 0, 0, 9298, 9293, 1, 0, 0, 0, 9298, 9297, 1, 0, 0, 0, 9299, 1221,
		1, 0, 0, 0, 9300, 9301, 5, 417, 0, 0, 9301, 9302, 5, 2, 0, 0, 9302, 9303,
		3, 1224, 612, 0, 9303, 9304, 5, 3, 0, 0, 9304, 1223, 1, 0, 0, 0, 9305,
		9310, 3, 1226, 613, 0, 9306, 9307, 5, 6, 0, 0, 9307, 9309, 3, 1226, 613,
		0, 9308, 9306, 1, 0, 0, 0, 9309, 9312, 1, 0, 0, 0, 9310, 9308, 1, 0, 0,
		0, 9310, 9311, 1, 0, 0, 0, 9311, 1225, 1, 0, 0, 0, 9312, 9310, 1, 0, 0,
		0, 9313, 9316, 3, 1162, 581, 0, 9314, 9315, 5, 36, 0, 0, 9315, 9317, 3,
		1380, 690, 0, 9316, 9314, 1, 0, 0, 0, 9316, 9317, 1, 0, 0, 0, 9317, 1227,
		1, 0, 0, 0, 9318, 9319, 7, 53, 0, 0, 9319, 1229, 1, 0, 0, 0, 9320, 9321,
		5, 285, 0, 0, 9321, 9326, 5, 371, 0, 0, 9322, 9323, 5, 340, 0, 0, 9323,
		9326, 5, 371, 0, 0, 9324, 9326, 1, 0, 0, 0, 9325, 9320, 1, 0, 0, 0, 9325,
		9322, 1, 0, 0, 0, 9325, 9324, 1, 0, 0, 0, 9326, 1231, 1, 0, 0, 0, 9327,
		9328, 5, 279, 0, 0, 9328, 9343, 3, 1206, 603, 0, 9329, 9330, 5, 279, 0,
		0, 9330, 9331, 3, 1206, 603, 0, 9331, 9332, 3, 1234, 617, 0, 9332, 9343,
		1, 0, 0, 0, 9333, 9334, 5, 279, 0, 0, 9334, 9335, 3, 1234, 617, 0, 9335,
		9336, 3, 1206, 603, 0, 9336, 9343, 1, 0, 0, 0, 9337, 9338, 5, 279, 0, 0,
		9338, 9339, 3, 1234, 617, 0, 9339, 9340, 3, 1206, 603, 0, 9340, 9341, 3,
		1234, 617, 0, 9341, 9343, 1, 0, 0, 0, 9342, 9327, 1, 0, 0, 0, 9342, 9329,
		1, 0, 0, 0, 9342, 9333, 1, 0, 0, 0, 9342, 9337, 1, 0, 0, 0, 9343, 1233,
		1, 0, 0, 0, 9344, 9345, 5, 147, 0, 0, 9345, 9346, 7, 54, 0, 0, 9346, 1235,
		1, 0, 0, 0, 9347, 9348, 5, 479, 0, 0, 9348, 9349, 5, 66, 0, 0, 9349, 9350,
		5, 2, 0, 0, 9350, 9351, 3, 998, 499, 0, 9351, 9352, 5, 3, 0, 0, 9352, 9355,
		1, 0, 0, 0, 9353, 9355, 1, 0, 0, 0, 9354, 9347, 1, 0, 0, 0, 9354, 9353,
		1, 0, 0, 0, 9355, 1237, 1, 0, 0, 0, 9356, 9357, 5, 480, 0, 0, 9357, 9358,
		5, 2, 0, 0, 9358, 9359, 5, 103, 0, 0, 9359, 9360, 3, 1162, 581, 0, 9360,
		9361, 5, 3, 0, 0, 9361, 9364, 1, 0, 0, 0, 9362, 9364, 1, 0, 0, 0, 9363,
		9356, 1, 0, 0, 0, 9363, 9362, 1, 0, 0, 0, 9364, 1239, 1, 0, 0, 0, 9365,
		9366, 5, 104, 0, 0, 9366, 9369, 3, 1242, 621, 0, 9367, 9369, 1, 0, 0, 0,
		9368, 9365, 1, 0, 0, 0, 9368, 9367, 1, 0, 0, 0, 9369, 1241, 1, 0, 0, 0,
		9370, 9375, 3, 1244, 622, 0, 9371, 9372, 5, 6, 0, 0, 9372, 9374, 3, 1244,
		622, 0, 9373, 9371, 1, 0, 0, 0, 9374, 9377, 1, 0, 0, 0, 9375, 9373, 1,
		0, 0, 0, 9375, 9376, 1, 0, 0, 0, 9376, 1243, 1, 0, 0, 0, 9377, 9375, 1,
		0, 0, 0, 9378, 9379, 3, 1372, 686, 0, 9379, 9380, 5, 36, 0, 0, 9380, 9381,
		3, 1248, 624, 0, 9381, 1245, 1, 0, 0, 0, 9382, 9385, 5, 124, 0, 0, 9383,
		9386, 3, 1248, 624, 0, 9384, 9386, 3, 1372, 686, 0, 9385, 9383, 1, 0, 0,
		0, 9385, 9384, 1, 0, 0, 0, 9386, 9389, 1, 0, 0, 0, 9387, 9389, 1, 0, 0,
		0, 9388, 9382, 1, 0, 0, 0, 9388, 9387, 1, 0, 0, 0, 9389, 1247, 1, 0, 0,
		0, 9390, 9391, 5, 2, 0, 0, 9391, 9392, 3, 1250, 625, 0, 9392, 9393, 3,
		1252, 626, 0, 9393, 9394, 3, 996, 498, 0, 9394, 9395, 3, 1254, 627, 0,
		9395, 9396, 5, 3, 0, 0, 9396, 1249, 1, 0, 0, 0, 9397, 9400, 3, 1372, 686,
		0, 9398, 9400, 1, 0, 0, 0, 9399, 9397, 1, 0, 0, 0, 9399, 9398, 1, 0, 0,
		0, 9400, 1251, 1, 0, 0, 0, 9401, 9402, 5, 278, 0, 0, 9402, 9403, 5, 147,
		0, 0, 9403, 9406, 3, 1280, 640, 0, 9404, 9406, 1, 0, 0, 0, 9405, 9401,
		1, 0, 0, 0, 9405, 9404, 1, 0, 0, 0, 9406, 1253, 1, 0, 0, 0, 9407, 9408,
		5, 292, 0, 0, 9408, 9409, 3, 1256, 628, 0, 9409, 9410, 3, 1260, 630, 0,
		9410, 9421, 1, 0, 0, 0, 9411, 9412, 5, 313, 0, 0, 9412, 9413, 3, 1256,
		628, 0, 9413, 9414, 3, 1260, 630, 0, 9414, 9421, 1, 0, 0, 0, 9415, 9416,
		5, 481, 0, 0, 9416, 9417, 3, 1256, 628, 0, 9417, 9418, 3, 1260, 630, 0,
		9418, 9421, 1, 0, 0, 0, 9419, 9421, 1, 0, 0, 0, 9420, 9407, 1, 0, 0, 0,
		9420, 9411, 1, 0, 0, 0, 9420, 9415, 1, 0, 0, 0, 9420, 9419, 1, 0, 0, 0,
		9421, 1255, 1, 0, 0, 0, 9422, 9429, 3, 1258, 629, 0, 9423, 9424, 5, 380,
		0, 0, 9424, 9425, 3, 1258, 629, 0, 9425, 9426, 5, 33, 0, 0, 9426, 9427,
		3, 1258, 629, 0, 9427, 9429, 1, 0, 0, 0, 9428, 9422, 1, 0, 0, 0, 9428,
		9423, 1, 0, 0, 0, 9429, 1257, 1, 0, 0, 0, 9430, 9431, 5, 355, 0, 0, 9431,
		9438, 7, 55, 0, 0, 9432, 9433, 5, 434, 0, 0, 9433, 9438, 5, 407, 0, 0,
		9434, 9435, 3, 1162, 581, 0, 9435, 9436, 7, 55, 0, 0, 9436, 9438, 1, 0,
		0, 0, 9437, 9430, 1, 0, 0, 0, 9437, 9432, 1, 0, 0, 0, 9437, 9434, 1, 0,
		0, 0, 9438, 1259, 1, 0, 0, 0, 9439, 9446, 5, 199, 0, 0, 9440, 9441, 5,
		434, 0, 0, 9441, 9447, 5, 407, 0, 0, 9442, 9447, 5, 66, 0, 0, 9443, 9447,
		5, 467, 0, 0, 9444, 9445, 5, 262, 0, 0, 9445, 9447, 5, 482, 0, 0, 9446,
		9440, 1, 0, 0, 0, 9446, 9442, 1, 0, 0, 0, 9446, 9443, 1, 0, 0, 0, 9446,
		9444, 1, 0, 0, 0, 9447, 9450, 1, 0, 0, 0, 9448, 9450, 1, 0, 0, 0, 9449,
		9439, 1, 0, 0, 0, 9449, 9448, 1, 0, 0, 0, 9450, 1261, 1, 0, 0, 0, 9451,
		9452, 5, 407, 0, 0, 9452, 9454, 5, 2, 0, 0, 9453, 9455, 3, 1280, 640, 0,
		9454, 9453, 1, 0, 0, 0, 9454, 9455, 1, 0, 0, 0, 9455, 9456, 1, 0, 0, 0,
		9456, 9464, 5, 3, 0, 0, 9457, 9458, 5, 2, 0, 0, 9458, 9459, 3, 1280, 640,
		0, 9459, 9460, 5, 6, 0, 0, 9460, 9461, 3, 1162, 581, 0, 9461, 9462, 5,
		3, 0, 0, 9462, 9464, 1, 0, 0, 0, 9463, 9451, 1, 0, 0, 0, 9463, 9457, 1,
		0, 0, 0, 9464, 1263, 1, 0, 0, 0, 9465, 9466, 5, 407, 0, 0, 9466, 9468,
		5, 2, 0, 0, 9467, 9469, 3, 1280, 640, 0, 9468, 9467, 1, 0, 0, 0, 9468,
		9469, 1, 0, 0, 0, 9469, 9470, 1, 0, 0, 0, 9470, 9471, 5, 3, 0, 0, 9471,
		1265, 1, 0, 0, 0, 9472, 9473, 5, 2, 0, 0, 9473, 9474, 3, 1280, 640, 0,
		9474, 9475, 5, 6, 0, 0, 9475, 9476, 3, 1162, 581, 0, 9476, 9477, 5, 3,
		0, 0, 9477, 1267, 1, 0, 0, 0, 9478, 9479, 7, 56, 0, 0, 9479, 1269, 1, 0,
		0, 0, 9480, 9483, 5, 29, 0, 0, 9481, 9483, 3, 1272, 636, 0, 9482, 9480,
		1, 0, 0, 0, 9482, 9481, 1, 0, 0, 0, 9483, 1271, 1, 0, 0, 0, 9484, 9485,
		7, 57, 0, 0, 9485, 1273, 1, 0, 0, 0, 9486, 9493, 5, 29, 0, 0, 9487, 9488,
		5, 271, 0, 0, 9488, 9489, 5, 2, 0, 0, 9489, 9490, 3, 684, 342, 0, 9490,
		9491, 5, 3, 0, 0, 9491, 9493, 1, 0, 0, 0, 9492, 9486, 1, 0, 0, 0, 9492,
		9487, 1, 0, 0, 0, 9493, 1275, 1, 0, 0, 0, 9494, 9501, 3, 1270, 635, 0,
		9495, 9496, 5, 271, 0, 0, 9496, 9497, 5, 2, 0, 0, 9497, 9498, 3, 684, 342,
		0, 9498, 9499, 5, 3, 0, 0, 9499, 9501, 1, 0, 0, 0, 9500, 9494, 1, 0, 0,
		0, 9500, 9495, 1, 0, 0, 0, 9501, 1277, 1, 0, 0, 0, 9502, 9515, 3, 1270,
		635, 0, 9503, 9504, 5, 271, 0, 0, 9504, 9505, 5, 2, 0, 0, 9505, 9506, 3,
		684, 342, 0, 9506, 9507, 5, 3, 0, 0, 9507, 9515, 1, 0, 0, 0, 9508, 9515,
		5, 120, 0, 0, 9509, 9510, 5, 77, 0, 0, 9510, 9515, 5, 120, 0, 0, 9511,
		9515, 5, 114, 0, 0, 9512, 9513, 5, 77, 0, 0, 9513, 9515, 5, 114, 0, 0,
		9514, 9502, 1, 0, 0, 0, 9514, 9503, 1, 0, 0, 0, 9514, 9508, 1, 0, 0, 0,
		9514, 9509, 1, 0, 0, 0, 9514, 9511, 1, 0, 0, 0, 9514, 9512, 1, 0, 0, 0,
		9515, 1279, 1, 0, 0, 0, 9516, 9521, 3, 1162, 581, 0, 9517, 9518, 5, 6,
		0, 0, 9518, 9520, 3, 1162, 581, 0, 9519, 9517, 1, 0, 0, 0, 9520, 9523,
		1, 0, 0, 0, 9521, 9519, 1, 0, 0, 0, 9521, 9522, 1, 0, 0, 0, 9522, 1281,
		1, 0, 0, 0, 9523, 9521, 1, 0, 0, 0, 9524, 9529, 3, 1284, 642, 0, 9525,
		9526, 5, 6, 0, 0, 9526, 9528, 3, 1284, 642, 0, 9527, 9525, 1, 0, 0, 0,
		9528, 9531, 1, 0, 0, 0, 9529, 9527, 1, 0, 0, 0, 9529, 9530, 1, 0, 0, 0,
		9530, 1283, 1, 0, 0, 0, 9531, 9529, 1, 0, 0, 0, 9532, 9538, 3, 1162, 581,
		0, 9533, 9534, 3, 636, 318, 0, 9534, 9535, 7, 58, 0, 0, 9535, 9536, 3,
		1162, 581, 0, 9536, 9538, 1, 0, 0, 0, 9537, 9532, 1, 0, 0, 0, 9537, 9533,
		1, 0, 0, 0, 9538, 1285, 1, 0, 0, 0, 9539, 9544, 3, 1118, 559, 0, 9540,
		9541, 5, 6, 0, 0, 9541, 9543, 3, 1118, 559, 0, 9542, 9540, 1, 0, 0, 0,
		9543, 9546, 1, 0, 0, 0, 9544, 9542, 1, 0, 0, 0, 9544, 9545, 1, 0, 0, 0,
		9545, 1287, 1, 0, 0, 0, 9546, 9544, 1, 0, 0, 0, 9547, 9550, 5, 4, 0, 0,
		9548, 9551, 3, 1280, 640, 0, 9549, 9551, 3, 1290, 645, 0, 9550, 9548, 1,
		0, 0, 0, 9550, 9549, 1, 0, 0, 0, 9550, 9551, 1, 0, 0, 0, 9551, 9552, 1,
		0, 0, 0, 9552, 9553, 5, 5, 0, 0, 9553, 1289, 1, 0, 0, 0, 9554, 9559, 3,
		1288, 644, 0, 9555, 9556, 5, 6, 0, 0, 9556, 9558, 3, 1288, 644, 0, 9557,
		9555, 1, 0, 0, 0, 9558, 9561, 1, 0, 0, 0, 9559, 9557, 1, 0, 0, 0, 9559,
		9560, 1, 0, 0, 0, 9560, 1291, 1, 0, 0, 0, 9561, 9559, 1, 0, 0, 0, 9562,
		9563, 3, 1294, 647, 0, 9563, 9564, 5, 64, 0, 0, 9564, 9565, 3, 1162, 581,
		0, 9565, 9568, 1, 0, 0, 0, 9566, 9568, 1, 0, 0, 0, 9567, 9562, 1, 0, 0,
		0, 9567, 9566, 1, 0, 0, 0, 9568, 1293, 1, 0, 0, 0, 9569, 9578, 3, 1382,
		691, 0, 9570, 9578, 5, 377, 0, 0, 9571, 9578, 5, 257, 0, 0, 9572, 9578,
		5, 176, 0, 0, 9573, 9578, 5, 218, 0, 0, 9574, 9578, 5, 254, 0, 0, 9575,
		9578, 5, 319, 0, 0, 9576, 9578, 3, 1358, 679, 0, 9577, 9569, 1, 0, 0, 0,
		9577, 9570, 1, 0, 0, 0, 9577, 9571, 1, 0, 0, 0, 9577, 9572, 1, 0, 0, 0,
		9577, 9573, 1, 0, 0, 0, 9577, 9574, 1, 0, 0, 0, 9577, 9575, 1, 0, 0, 0,
		9577, 9576, 1, 0, 0, 0, 9578, 1295, 1, 0, 0, 0, 9579, 9580, 7, 59, 0, 0,
		9580, 1297, 1, 0, 0, 0, 9581, 9582, 3, 1162, 581, 0, 9582, 9583, 5, 84,
		0, 0, 9583, 9584, 3, 1162, 581, 0, 9584, 9585, 5, 64, 0, 0, 9585, 9588,
		3, 1162, 581, 0, 9586, 9587, 5, 62, 0, 0, 9587, 9589, 3, 1162, 581, 0,
		9588, 9586, 1, 0, 0, 0, 9588, 9589, 1, 0, 0, 0, 9589, 1299, 1, 0, 0, 0,
		9590, 9591, 3, 1204, 602, 0, 9591, 9592, 5, 68, 0, 0, 9592, 9593, 3, 1204,
		602, 0, 9593, 9596, 1, 0, 0, 0, 9594, 9596, 1, 0, 0, 0, 9595, 9590, 1,
		0, 0, 0, 9595, 9594, 1, 0, 0, 0, 9596, 1301, 1, 0, 0, 0, 9597, 9598, 3,
		1162, 581, 0, 9598, 9599, 5, 64, 0, 0, 9599, 9600, 3, 1162, 581, 0, 9600,
		9601, 5, 62, 0, 0, 9601, 9602, 3, 1162, 581, 0, 9602, 9625, 1, 0, 0, 0,
		9603, 9604, 3, 1162, 581, 0, 9604, 9605, 5, 62, 0, 0, 9605, 9606, 3, 1162,
		581, 0, 9606, 9607, 5, 64, 0, 0, 9607, 9608, 3, 1162, 581, 0, 9608, 9625,
		1, 0, 0, 0, 9609, 9610, 3, 1162, 581, 0, 9610, 9611, 5, 64, 0, 0, 9611,
		9612, 3, 1162, 581, 0, 9612, 9625, 1, 0, 0, 0, 9613, 9614, 3, 1162, 581,
		0, 9614, 9615, 5, 62, 0, 0, 9615, 9616, 3, 1162, 581, 0, 9616, 9625, 1,
		0, 0, 0, 9617, 9618, 3, 1162, 581, 0, 9618, 9619, 5, 127, 0, 0, 9619, 9620,
		3, 1162, 581, 0, 9620, 9621, 5, 197, 0, 0, 9621, 9622, 3, 1162, 581, 0,
		9622, 9625, 1, 0, 0, 0, 9623, 9625, 3, 1280, 640, 0, 9624, 9597, 1, 0,
		0, 0, 9624, 9603, 1, 0, 0, 0, 9624, 9609, 1, 0, 0, 0, 9624, 9613, 1, 0,
		0, 0, 9624, 9617, 1, 0, 0, 0, 9624, 9623, 1, 0, 0, 0, 9625, 1303, 1, 0,
		0, 0, 9626, 9627, 3, 1162, 581, 0, 9627, 9628, 5, 64, 0, 0, 9628, 9629,
		3, 1280, 640, 0, 9629, 9634, 1, 0, 0, 0, 9630, 9631, 5, 64, 0, 0, 9631,
		9634, 3, 1280, 640, 0, 9632, 9634, 3, 1280, 640, 0, 9633, 9626, 1, 0, 0,
		0, 9633, 9630, 1, 0, 0, 0, 9633, 9632, 1, 0, 0, 0, 9634, 1305, 1, 0, 0,
		0, 9635, 9641, 3, 962, 481, 0, 9636, 9637, 5, 2, 0, 0, 9637, 9638, 3, 1280,
		640, 0, 9638, 9639, 5, 3, 0, 0, 9639, 9641, 1, 0, 0, 0, 9640, 9635, 1,
		0, 0, 0, 9640, 9636, 1, 0, 0, 0, 9641, 1307, 1, 0, 0, 0, 9642, 9643, 5,
		40, 0, 0, 9643, 9644, 3, 1316, 658, 0, 9644, 9645, 3, 1310, 655, 0, 9645,
		9646, 3, 1314, 657, 0, 9646, 9647, 5, 454, 0, 0, 9647, 1309, 1, 0, 0, 0,
		9648, 9650, 3, 1312, 656, 0, 9649, 9648, 1, 0, 0, 0, 9650, 9651, 1, 0,
		0, 0, 9651, 9649, 1, 0, 0, 0, 9651, 9652, 1, 0, 0, 0, 9652, 1311, 1, 0,
		0, 0, 9653, 9654, 5, 102, 0, 0, 9654, 9655, 3, 1162, 581, 0, 9655, 9656,
		5, 93, 0, 0, 9656, 9657, 3, 1162, 581, 0, 9657, 1313, 1, 0, 0, 0, 9658,
		9659, 5, 58, 0, 0, 9659, 9662, 3, 1162, 581, 0, 9660, 9662, 1, 0, 0, 0,
		9661, 9658, 1, 0, 0, 0, 9661, 9660, 1, 0, 0, 0, 9662, 1315, 1, 0, 0, 0,
		9663, 9666, 3, 1162, 581, 0, 9664, 9666, 1, 0, 0, 0, 9665, 9663, 1, 0,
		0, 0, 9665, 9664, 1, 0, 0, 0, 9666, 1317, 1, 0, 0, 0, 9667, 9669, 3, 1372,
		686, 0, 9668, 9670, 3, 1324, 662, 0, 9669, 9668, 1, 0, 0, 0, 9669, 9670,
		1, 0, 0, 0, 9670, 1319, 1, 0, 0, 0, 9671, 9674, 5, 11, 0, 0, 9672, 9675,
		3, 1342, 671, 0, 9673, 9675, 5, 9, 0, 0, 9674, 9672, 1, 0, 0, 0, 9674,
		9673, 1, 0, 0, 0, 9675, 9687, 1, 0, 0, 0, 9676, 9682, 5, 4, 0, 0, 9677,
		9683, 3, 1162, 581, 0, 9678, 9679, 3, 1322, 661, 0, 9679, 9680, 5, 8, 0,
		0, 9680, 9681, 3, 1322, 661, 0, 9681, 9683, 1, 0, 0, 0, 9682, 9677, 1,
		0, 0, 0, 9682, 9678, 1, 0, 0, 0, 9683, 9684, 1, 0, 0, 0, 9684, 9685, 5,
		5, 0, 0, 9685, 9687, 1, 0, 0, 0, 9686, 9671, 1, 0, 0, 0, 9686, 9676, 1,
		0, 0, 0, 9687, 1321, 1, 0, 0, 0, 9688, 9691, 3, 1162, 581, 0, 9689, 9691,
		1, 0, 0, 0, 9690, 9688, 1, 0, 0, 0, 9690, 9689, 1, 0, 0, 0, 9691, 1323,
		1, 0, 0, 0, 9692, 9694, 3, 1320, 660, 0, 9693, 9692, 1, 0, 0, 0, 9694,
		9695, 1, 0, 0, 0, 9695, 9693, 1, 0, 0, 0, 9695, 9696, 1, 0, 0, 0, 9696,
		1325, 1, 0, 0, 0, 9697, 9699, 3, 1320, 660, 0, 9698, 9697, 1, 0, 0, 0,
		9699, 9702, 1, 0, 0, 0, 9700, 9698, 1, 0, 0, 0, 9700, 9701, 1, 0, 0, 0,
		9701, 1327, 1, 0, 0, 0, 9702, 9700, 1, 0, 0, 0, 9703, 9706, 3, 1330, 665,
		0, 9704, 9706, 1, 0, 0, 0, 9705, 9703, 1, 0, 0, 0, 9705, 9704, 1, 0, 0,
		0, 9706, 1329, 1, 0, 0, 0, 9707, 9712, 3, 1332, 666, 0, 9708, 9709, 5,
		6, 0, 0, 9709, 9711, 3, 1332, 666, 0, 9710, 9708, 1, 0, 0, 0, 9711, 9714,
		1, 0, 0, 0, 9712, 9710, 1, 0, 0, 0, 9712, 9713, 1, 0, 0, 0, 9713, 1331,
		1, 0, 0, 0, 9714, 9712, 1, 0, 0, 0, 9715, 9720, 3, 1162, 581, 0, 9716,
		9717, 5, 36, 0, 0, 9717, 9721, 3, 1380, 690, 0, 9718, 9721, 3, 1382, 691,
		0, 9719, 9721, 1, 0, 0, 0, 9720, 9716, 1, 0, 0, 0, 9720, 9718, 1, 0, 0,
		0, 9720, 9719, 1, 0, 0, 0, 9721, 9724, 1, 0, 0, 0, 9722, 9724, 5, 9, 0,
		0, 9723, 9715, 1, 0, 0, 0, 9723, 9722, 1, 0, 0, 0, 9724, 1333, 1, 0, 0,
		0, 9725, 9730, 3, 1336, 668, 0, 9726, 9727, 5, 6, 0, 0, 9727, 9729, 3,
		1336, 668, 0, 9728, 9726, 1, 0, 0, 0, 9729, 9732, 1, 0, 0, 0, 9730, 9728,
		1, 0, 0, 0, 9730, 9731, 1, 0, 0, 0, 9731, 1335, 1, 0, 0, 0, 9732, 9730,
		1, 0, 0, 0, 9733, 9735, 3, 1372, 686, 0, 9734, 9736, 3, 1324, 662, 0, 9735,
		9734, 1, 0, 0, 0, 9735, 9736, 1, 0, 0, 0, 9736, 1337, 1, 0, 0, 0, 9737,
		9742, 3, 1340, 670, 0, 9738, 9739, 5, 6, 0, 0, 9739, 9741, 3, 1340, 670,
		0, 9740, 9738, 1, 0, 0, 0, 9741, 9744, 1, 0, 0, 0, 9742, 9740, 1, 0, 0,
		0, 9742, 9743, 1, 0, 0, 0, 9743, 1339, 1, 0, 0, 0, 9744, 9742, 1, 0, 0,
		0, 9745, 9746, 3, 1372, 686, 0, 9746, 1341, 1, 0, 0, 0, 9747, 9748, 3,
		1380, 690, 0, 9748, 1343, 1, 0, 0, 0, 9749, 9750, 3, 1358, 679, 0, 9750,
		1345, 1, 0, 0, 0, 9751, 9759, 3, 1394, 697, 0, 9752, 9759, 3, 1376, 688,
		0, 9753, 9754, 3, 1372, 686, 0, 9754, 9755, 3, 1324, 662, 0, 9755, 9759,
		1, 0, 0, 0, 9756, 9759, 5, 119, 0, 0, 9757, 9759, 5, 126, 0, 0, 9758, 9751,
		1, 0, 0, 0, 9758, 9752, 1, 0, 0, 0, 9758, 9753, 1, 0, 0, 0, 9758, 9756,
		1, 0, 0, 0, 9758, 9757, 1, 0, 0, 0, 9759, 1347, 1, 0, 0, 0, 9760, 9793,
		3, 1356, 678, 0, 9761, 9793, 3, 1354, 677, 0, 9762, 9793, 3, 1358, 679,
		0, 9763, 9793, 3, 1352, 676, 0, 9764, 9793, 3, 1350, 675, 0, 9765, 9773,
		3, 1346, 673, 0, 9766, 9774, 3, 1358, 679, 0, 9767, 9768, 5, 2, 0, 0, 9768,
		9769, 3, 1282, 641, 0, 9769, 9770, 3, 996, 498, 0, 9770, 9771, 5, 3, 0,
		0, 9771, 9772, 3, 1358, 679, 0, 9772, 9774, 1, 0, 0, 0, 9773, 9766, 1,
		0, 0, 0, 9773, 9767, 1, 0, 0, 0, 9774, 9793, 1, 0, 0, 0, 9775, 9776, 3,
		1124, 562, 0, 9776, 9777, 3, 1358, 679, 0, 9777, 9793, 1, 0, 0, 0, 9778,
		9787, 3, 1152, 576, 0, 9779, 9780, 3, 1358, 679, 0, 9780, 9781, 3, 1156,
		578, 0, 9781, 9788, 1, 0, 0, 0, 9782, 9783, 5, 2, 0, 0, 9783, 9784, 3,
		1356, 678, 0, 9784, 9785, 5, 3, 0, 0, 9785, 9786, 3, 1358, 679, 0, 9786,
		9788, 1, 0, 0, 0, 9787, 9779, 1, 0, 0, 0, 9787, 9782, 1, 0, 0, 0, 9788,
		9793, 1, 0, 0, 0, 9789, 9793, 5, 96, 0, 0, 9790, 9793, 5, 60, 0, 0, 9791,
		9793, 5, 78, 0, 0, 9792, 9760, 1, 0, 0, 0, 9792, 9761, 1, 0, 0, 0, 9792,
		9762, 1, 0, 0, 0, 9792, 9763, 1, 0, 0, 0, 9792, 9764, 1, 0, 0, 0, 9792,
		9765, 1, 0, 0, 0, 9792, 9775, 1, 0, 0, 0, 9792, 9778, 1, 0, 0, 0, 9792,
		9789, 1, 0, 0, 0, 9792, 9790, 1, 0, 0, 0, 9792, 9791, 1, 0, 0, 0, 9793,
		1349, 1, 0, 0, 0, 9794, 9795, 5, 654, 0, 0, 9795, 1351, 1, 0, 0, 0, 9796,
		9797, 5, 650, 0, 0, 9797, 1353, 1, 0, 0, 0, 9798, 9799, 5, 660, 0, 0, 9799,
		1355, 1, 0, 0, 0, 9800, 9801, 5, 658, 0, 0, 9801, 1357, 1, 0, 0, 0, 9802,
		9803, 3, 1360, 680, 0, 9803, 9804, 3, 1362, 681, 0, 9804, 1359, 1, 0, 0,
		0, 9805, 9817, 5, 645, 0, 0, 9806, 9817, 5, 647, 0, 0, 9807, 9811, 5, 649,
		0, 0, 9808, 9810, 5, 677, 0, 0, 9809, 9808, 1, 0, 0, 0, 9810, 9813, 1,
		0, 0, 0, 9811, 9809, 1, 0, 0, 0, 9811, 9812, 1, 0, 0, 0, 9812, 9814, 1,
		0, 0, 0, 9813, 9811, 1, 0, 0, 0, 9814, 9817, 5, 678, 0, 0, 9815, 9817,
		5, 671, 0, 0, 9816, 9805, 1, 0, 0, 0, 9816, 9806, 1, 0, 0, 0, 9816, 9807,
		1, 0, 0, 0, 9816, 9815, 1, 0, 0, 0, 9817, 1361, 1, 0, 0, 0, 9818, 9819,
		5, 487, 0, 0, 9819, 9822, 3, 1360, 680, 0, 9820, 9822, 1, 0, 0, 0, 9821,
		9818, 1, 0, 0, 0, 9821, 9820, 1, 0, 0, 0, 9822, 1363, 1, 0, 0, 0, 9823,
		9829, 3, 1356, 678, 0, 9824, 9825, 5, 12, 0, 0, 9825, 9829, 3, 1356, 678,
		0, 9826, 9827, 5, 13, 0, 0, 9827, 9829, 3, 1356, 678, 0, 9828, 9823, 1,
		0, 0, 0, 9828, 9824, 1, 0, 0, 0, 9828, 9826, 1, 0, 0, 0, 9829, 1365, 1,
		0, 0, 0, 9830, 9831, 3, 1368, 684, 0, 9831, 1367, 1, 0, 0, 0, 9832, 9836,
		3, 1378, 689, 0, 9833, 9836, 5, 52, 0, 0, 9834, 9836, 5, 89, 0, 0, 9835,
		9832, 1, 0, 0, 0, 9835, 9833, 1, 0, 0, 0, 9835, 9834, 1, 0, 0, 0, 9836,
		1369, 1, 0, 0, 0, 9837, 9842, 3, 1368, 684, 0, 9838, 9839, 5, 6, 0, 0,
		9839, 9841, 3, 1368, 684, 0, 9840, 9838, 1, 0, 0, 0, 9841, 9844, 1, 0,
		0, 0, 9842, 9840, 1, 0, 0, 0, 9842, 9843, 1, 0, 0, 0, 9843, 1371, 1, 0,
		0, 0, 9844, 9842, 1, 0, 0, 0, 9845, 9852, 3, 1382, 691, 0, 9846, 9852,
		3, 1386, 693, 0, 9847, 9852, 3, 1388, 694, 0, 9848, 9852, 3, 1608, 804,
		0, 9849, 9852, 5, 119, 0, 0, 9850, 9852, 5, 126, 0, 0, 9851, 9845, 1, 0,
		0, 0, 9851, 9846, 1, 0, 0, 0, 9851, 9847, 1, 0, 0, 0, 9851, 9848, 1, 0,
		0, 0, 9851, 9849, 1, 0, 0, 0, 9851, 9850, 1, 0, 0, 0, 9852, 1373, 1, 0,
		0, 0, 9853, 9858, 3, 1382, 691, 0, 9854, 9858, 3, 1386, 693, 0, 9855, 9858,
		3, 1388, 694, 0, 9856, 9858, 3, 1608, 804, 0, 9857, 9853, 1, 0, 0, 0, 9857,
		9854, 1, 0, 0, 0, 9857, 9855, 1, 0, 0, 0, 9857, 9856, 1, 0, 0, 0, 9858,
		1375, 1, 0, 0, 0, 9859, 9864, 3, 1382, 691, 0, 9860, 9864, 3, 1386, 693,
		0, 9861, 9864, 3, 1608, 804, 0, 9862, 9864, 3, 1390, 695, 0, 9863, 9859,
		1, 0, 0, 0, 9863, 9860, 1, 0, 0, 0, 9863, 9861, 1, 0, 0, 0, 9863, 9862,
		1, 0, 0, 0, 9864, 1377, 1, 0, 0, 0, 9865, 9870, 3, 1382, 691, 0, 9866,
		9870, 3, 1386, 693, 0, 9867, 9870, 3, 1388, 694, 0, 9868, 9870, 3, 1390,
		695, 0, 9869, 9865, 1, 0, 0, 0, 9869, 9866, 1, 0, 0, 0, 9869, 9867, 1,
		0, 0, 0, 9869, 9868, 1, 0, 0, 0, 9870, 1379, 1, 0, 0, 0, 9871, 9878, 3,
		1382, 691, 0, 9872, 9878, 3, 1608, 804, 0, 9873, 9878, 3, 1386, 693, 0,
		9874, 9878, 3, 1388, 694, 0, 9875, 9878, 3, 1390, 695, 0, 9876, 9878, 3,
		1392, 696, 0, 9877, 9871, 1, 0, 0, 0, 9877, 9872, 1, 0, 0, 0, 9877, 9873,
		1, 0, 0, 0, 9877, 9874, 1, 0, 0, 0, 9877, 9875, 1, 0, 0, 0, 9877, 9876,
		1, 0, 0, 0, 9878, 1381, 1, 0, 0, 0, 9879, 9880, 5, 636, 0, 0, 9880, 9887,
		3, 1362, 681, 0, 9881, 9887, 5, 637, 0, 0, 9882, 9887, 5, 641, 0, 0, 9883,
		9887, 3, 1208, 604, 0, 9884, 9887, 3, 1384, 692, 0, 9885, 9887, 3, 1608,
		804, 0, 9886, 9879, 1, 0, 0, 0, 9886, 9881, 1, 0, 0, 0, 9886, 9882, 1,
		0, 0, 0, 9886, 9883, 1, 0, 0, 0, 9886, 9884, 1, 0, 0, 0, 9886, 9885, 1,
		0, 0, 0, 9887, 1383, 1, 0, 0, 0, 9888, 9889, 5, 662, 0, 0, 9889, 1385,
		1, 0, 0, 0, 9890, 9891, 7, 60, 0, 0, 9891, 1387, 1, 0, 0, 0, 9892, 9945,
		5, 380, 0, 0, 9893, 9945, 5, 381, 0, 0, 9894, 9945, 3, 1134, 567, 0, 9895,
		9945, 5, 383, 0, 0, 9896, 9945, 5, 384, 0, 0, 9897, 9945, 3, 1142, 571,
		0, 9898, 9945, 5, 386, 0, 0, 9899, 9945, 5, 387, 0, 0, 9900, 9945, 5, 388,
		0, 0, 9901, 9945, 5, 389, 0, 0, 9902, 9945, 5, 390, 0, 0, 9903, 9945, 5,
		391, 0, 0, 9904, 9945, 5, 392, 0, 0, 9905, 9945, 5, 470, 0, 0, 9906, 9945,
		5, 393, 0, 0, 9907, 9945, 5, 394, 0, 0, 9908, 9945, 5, 395, 0, 0, 9909,
		9945, 5, 396, 0, 0, 9910, 9945, 5, 397, 0, 0, 9911, 9945, 5, 398, 0, 0,
		9912, 9945, 5, 399, 0, 0, 9913, 9945, 5, 400, 0, 0, 9914, 9945, 5, 489,
		0, 0, 9915, 9945, 5, 401, 0, 0, 9916, 9945, 3, 1130, 565, 0, 9917, 9945,
		5, 453, 0, 0, 9918, 9945, 5, 403, 0, 0, 9919, 9945, 5, 404, 0, 0, 9920,
		9945, 5, 405, 0, 0, 9921, 9945, 5, 406, 0, 0, 9922, 9945, 5, 407, 0, 0,
		9923, 9945, 5, 408, 0, 0, 9924, 9945, 5, 409, 0, 0, 9925, 9945, 5, 410,
		0, 0, 9926, 9945, 5, 411, 0, 0, 9927, 9945, 5, 412, 0, 0, 9928, 9945, 5,
		413, 0, 0, 9929, 9945, 5, 414, 0, 0, 9930, 9945, 5, 415, 0, 0, 9931, 9945,
		5, 416, 0, 0, 9932, 9945, 5, 417, 0, 0, 9933, 9945, 5, 425, 0, 0, 9934,
		9945, 5, 426, 0, 0, 9935, 9945, 5, 427, 0, 0, 9936, 9945, 5, 428, 0, 0,
		9937, 9945, 5, 476, 0, 0, 9938, 9945, 5, 429, 0, 0, 9939, 9945, 5, 430,
		0, 0, 9940, 9945, 5, 431, 0, 0, 9941, 9945, 5, 432, 0, 0, 9942, 9945, 5,
		474, 0, 0, 9943, 9945, 3, 1394, 697, 0, 9944, 9892, 1, 0, 0, 0, 9944, 9893,
		1, 0, 0, 0, 9944, 9894, 1, 0, 0, 0, 9944, 9895, 1, 0, 0, 0, 9944, 9896,
		1, 0, 0, 0, 9944, 9897, 1, 0, 0, 0, 9944, 9898, 1, 0, 0, 0, 9944, 9899,
		1, 0, 0, 0, 9944, 9900, 1, 0, 0, 0, 9944, 9901, 1, 0, 0, 0, 9944, 9902,
		1, 0, 0, 0, 9944, 9903, 1, 0, 0, 0, 9944, 9904, 1, 0, 0, 0, 9944, 9905,
		1, 0, 0, 0, 9944, 9906, 1, 0, 0, 0, 9944, 9907, 1, 0, 0, 0, 9944, 9908,
		1, 0, 0, 0, 9944, 9909, 1, 0, 0, 0, 9944, 9910, 1, 0, 0, 0, 9944, 9911,
		1, 0, 0, 0, 9944, 9912, 1, 0, 0, 0, 9944, 9913, 1, 0, 0, 0, 9944, 9914,
		1, 0, 0, 0, 9944, 9915, 1, 0, 0, 0, 9944, 9916, 1, 0, 0, 0, 9944, 9917,
		1, 0, 0, 0, 9944, 9918, 1, 0, 0, 0, 9944, 9919, 1, 0, 0, 0, 9944, 9920,
		1, 0, 0, 0, 9944, 9921, 1, 0, 0, 0, 9944, 9922, 1, 0, 0, 0, 9944, 9923,
		1, 0, 0, 0, 9944, 9924, 1, 0, 0, 0, 9944, 9925, 1, 0, 0, 0, 9944, 9926,
		1, 0, 0, 0, 9944, 9927, 1, 0, 0, 0, 9944, 9928, 1, 0, 0, 0, 9944, 9929,
		1, 0, 0, 0, 9944, 9930, 1, 0, 0, 0, 9944, 9931, 1, 0, 0, 0, 9944, 9932,
		1, 0, 0, 0, 9944, 9933, 1, 0, 0, 0, 9944, 9934, 1, 0, 0, 0, 9944, 9935,
		1, 0, 0, 0, 9944, 9936, 1, 0, 0, 0, 9944, 9937, 1, 0, 0, 0, 9944, 9938,
		1, 0, 0, 0, 9944, 9939, 1, 0, 0, 0, 9944, 9940, 1, 0, 0, 0, 9944, 9941,
		1, 0, 0, 0, 9944, 9942, 1, 0, 0, 0, 9944, 9943, 1, 0, 0, 0, 9945, 1389,
		1, 0, 0, 0, 9946, 9947, 7, 61, 0, 0, 9947, 1391, 1, 0, 0, 0, 9948, 9949,
		7, 62, 0, 0, 9949, 1393, 1, 0, 0, 0, 9950, 9951, 7, 63, 0, 0, 9951, 1395,
		1, 0, 0, 0, 9952, 9953, 3, 1398, 699, 0, 9953, 9954, 3, 1408, 704, 0, 9954,
		9955, 3, 1406, 703, 0, 9955, 1397, 1, 0, 0, 0, 9956, 9958, 3, 1400, 700,
		0, 9957, 9956, 1, 0, 0, 0, 9958, 9961, 1, 0, 0, 0, 9959, 9957, 1, 0, 0,
		0, 9959, 9960, 1, 0, 0, 0, 9960, 1399, 1, 0, 0, 0, 9961, 9959, 1, 0, 0,
		0, 9962, 9963, 3, 1402, 701, 0, 9963, 9964, 5, 272, 0, 0, 9964, 9965, 5,
		490, 0, 0, 9965, 9983, 1, 0, 0, 0, 9966, 9967, 3, 1402, 701, 0, 9967, 9968,
		5, 491, 0, 0, 9968, 9969, 3, 1404, 702, 0, 9969, 9983, 1, 0, 0, 0, 9970,
		9971, 3, 1402, 701, 0, 9971, 9972, 5, 492, 0, 0, 9972, 9973, 5, 493, 0,
		0, 9973, 9983, 1, 0, 0, 0, 9974, 9975, 3, 1402, 701, 0, 9975, 9976, 5,
		492, 0, 0, 9976, 9977, 5, 494, 0, 0, 9977, 9983, 1, 0, 0, 0, 9978, 9979,
		3, 1402, 701, 0, 9979, 9980, 5, 492, 0, 0, 9980, 9981, 5, 495, 0, 0, 9981,
		9983, 1, 0, 0, 0, 9982, 9962, 1, 0, 0, 0, 9982, 9966, 1, 0, 0, 0, 9982,
		9970, 1, 0, 0, 0, 9982, 9974, 1, 0, 0, 0, 9982, 9978, 1, 0, 0, 0, 9983,
		1401, 1, 0, 0, 0, 9984, 9985, 5, 29, 0, 0, 9985, 1403, 1, 0, 0, 0, 9986,
		9991, 3, 1358, 679, 0, 9987, 9991, 3, 1392, 696, 0, 9988, 9991, 3, 1608,
		804, 0, 9989, 9991, 3, 1386, 693, 0, 9990, 9986, 1, 0, 0, 0, 9990, 9987,
		1, 0, 0, 0, 9990, 9988, 1, 0, 0, 0, 9990, 9989, 1, 0, 0, 0, 9991, 1405,
		1, 0, 0, 0, 9992, 9995, 1, 0, 0, 0, 9993, 9995, 5, 7, 0, 0, 9994, 9992,
		1, 0, 0, 0, 9994, 9993, 1, 0, 0, 0, 9995, 1407, 1, 0, 0, 0, 9996, 9997,
		3, 1410, 705, 0, 9997, 9998, 5, 146, 0, 0, 9998, 9999, 3, 1452, 726, 0,
		9999, 10000, 3, 1588, 794, 0, 10000, 10001, 5, 454, 0, 0, 10001, 10002,
		3, 1602, 801, 0, 10002, 1409, 1, 0, 0, 0, 10003, 10008, 3, 1598, 799, 0,
		10004, 10006, 3, 1412, 706, 0, 10005, 10007, 3, 1414, 707, 0, 10006, 10005,
		1, 0, 0, 0, 10006, 10007, 1, 0, 0, 0, 10007, 10009, 1, 0, 0, 0, 10008,
		10004, 1, 0, 0, 0, 10008, 10009, 1, 0, 0, 0, 10009, 1411, 1, 0, 0, 0, 10010,
		10011, 5, 178, 0, 0, 10011, 1413, 1, 0, 0, 0, 10012, 10014, 3, 1418, 709,
		0, 10013, 10012, 1, 0, 0, 0, 10014, 10015, 1, 0, 0, 0, 10015, 10013, 1,
		0, 0, 0, 10015, 10016, 1, 0, 0, 0, 10016, 1415, 1, 0, 0, 0, 10017, 10018,
		5, 18, 0, 0, 10018, 10019, 3, 1606, 803, 0, 10019, 10020, 5, 19, 0, 0,
		10020, 1417, 1, 0, 0, 0, 10021, 10025, 3, 1420, 710, 0, 10022, 10025, 5,
		178, 0, 0, 10023, 10025, 3, 1416, 708, 0, 10024, 10021, 1, 0, 0, 0, 10024,
		10022, 1, 0, 0, 0, 10024, 10023, 1, 0, 0, 0, 10025, 1419, 1, 0, 0, 0, 10026,
		10042, 3, 1436, 718, 0, 10027, 10028, 5, 496, 0, 0, 10028, 10029, 5, 62,
		0, 0, 10029, 10043, 3, 1434, 717, 0, 10030, 10031, 3, 1438, 719, 0, 10031,
		10032, 3, 1440, 720, 0, 10032, 10033, 3, 1442, 721, 0, 10033, 10034, 3,
		1444, 722, 0, 10034, 10035, 3, 1446, 723, 0, 10035, 10043, 1, 0, 0, 0,
		10036, 10037, 3, 1422, 711, 0, 10037, 10038, 5, 172, 0, 0, 10038, 10039,
		3, 1426, 713, 0, 10039, 10040, 3, 1432, 716, 0, 10040, 10041, 3, 1424,
		712, 0, 10041, 10043, 1, 0, 0, 0, 10042, 10027, 1, 0, 0, 0, 10042, 10030,
		1, 0, 0, 0, 10042, 10036, 1, 0, 0, 0, 10043, 10044, 1, 0, 0, 0, 10044,
		10045, 5, 7, 0, 0, 10045, 1421, 1, 0, 0, 0, 10046, 10051, 1, 0, 0, 0, 10047,
		10048, 5, 262, 0, 0, 10048, 10051, 5, 317, 0, 0, 10049, 10051, 5, 317,
		0, 0, 10050, 10046, 1, 0, 0, 0, 10050, 10047, 1, 0, 0, 0, 10050, 10049,
		1, 0, 0, 0, 10051, 1423, 1, 0, 0, 0, 10052, 10053, 3, 960, 480, 0, 10053,
		1425, 1, 0, 0, 0, 10054, 10060, 1, 0, 0, 0, 10055, 10056, 5, 2, 0, 0, 10056,
		10057, 3, 1428, 714, 0, 10057, 10058, 5, 3, 0, 0, 10058, 10060, 1, 0, 0,
		0, 10059, 10054, 1, 0, 0, 0, 10059, 10055, 1, 0, 0, 0, 10060, 1427, 1,
		0, 0, 0, 10061, 10066, 3, 1430, 715, 0, 10062, 10063, 5, 6, 0, 0, 10063,
		10065, 3, 1430, 715, 0, 10064, 10062, 1, 0, 0, 0, 10065, 10068, 1, 0, 0,
		0, 10066, 10064, 1, 0, 0, 0, 10066, 10067, 1, 0, 0, 0, 10067, 1429, 1,
		0, 0, 0, 10068, 10066, 1, 0, 0, 0, 10069, 10070, 3, 1436, 718, 0, 10070,
		10071, 3, 1440, 720, 0, 10071, 1431, 1, 0, 0, 0, 10072, 10073, 7, 64, 0,
		0, 10073, 1433, 1, 0, 0, 0, 10074, 10077, 5, 28, 0, 0, 10075, 10077, 3,
		1372, 686, 0, 10076, 10074, 1, 0, 0, 0, 10076, 10075, 1, 0, 0, 0, 10077,
		1435, 1, 0, 0, 0, 10078, 10079, 3, 1606, 803, 0, 10079, 1437, 1, 0, 0,
		0, 10080, 10083, 1, 0, 0, 0, 10081, 10083, 5, 497, 0, 0, 10082, 10080,
		1, 0, 0, 0, 10082, 10081, 1, 0, 0, 0, 10083, 1439, 1, 0, 0, 0, 10084, 10085,
		3, 1118, 559, 0, 10085, 1441, 1, 0, 0, 0, 10086, 10090, 1, 0, 0, 0, 10087,
		10088, 5, 43, 0, 0, 10088, 10090, 3, 524, 262, 0, 10089, 10086, 1, 0, 0,
		0, 10089, 10087, 1, 0, 0, 0, 10090, 1443, 1, 0, 0, 0, 10091, 10095, 1,
		0, 0, 0, 10092, 10093, 5, 77, 0, 0, 10093, 10095, 5, 78, 0, 0, 10094, 10091,
		1, 0, 0, 0, 10094, 10092, 1, 0, 0, 0, 10095, 1445, 1, 0, 0, 0, 10096, 10101,
		1, 0, 0, 0, 10097, 10098, 3, 1448, 724, 0, 10098, 10099, 3, 1610, 805,
		0, 10099, 10101, 1, 0, 0, 0, 10100, 10096, 1, 0, 0, 0, 10100, 10097, 1,
		0, 0, 0, 10101, 1447, 1, 0, 0, 0, 10102, 10105, 3, 1450, 725, 0, 10103,
		10105, 5, 53, 0, 0, 10104, 10102, 1, 0, 0, 0, 10104, 10103, 1, 0, 0, 0,
		10105, 1449, 1, 0, 0, 0, 10106, 10107, 7, 65, 0, 0, 10107, 1451, 1, 0,
		0, 0, 10108, 10110, 3, 1454, 727, 0, 10109, 10108, 1, 0, 0, 0, 10110, 10113,
		1, 0, 0, 0, 10111, 10109, 1, 0, 0, 0, 10111, 10112, 1, 0, 0, 0, 10112,
		1453, 1, 0, 0, 0, 10113, 10111, 1, 0, 0, 0, 10114, 10115, 3, 1408, 704,
		0, 10115, 10116, 5, 7, 0, 0, 10116, 10142, 1, 0, 0, 0, 10117, 10142, 3,
		1520, 760, 0, 10118, 10142, 3, 1524, 762, 0, 10119, 10142, 3, 1462, 731,
		0, 10120, 10142, 3, 1478, 739, 0, 10121, 10142, 3, 1484, 742, 0, 10122,
		10142, 3, 1494, 747, 0, 10123, 10142, 3, 1496, 748, 0, 10124, 10142, 3,
		1498, 749, 0, 10125, 10142, 3, 1512, 756, 0, 10126, 10142, 3, 1516, 758,
		0, 10127, 10142, 3, 1536, 768, 0, 10128, 10142, 3, 1542, 771, 0, 10129,
		10142, 3, 1544, 772, 0, 10130, 10142, 3, 1456, 728, 0, 10131, 10142, 3,
		1458, 729, 0, 10132, 10142, 3, 1464, 732, 0, 10133, 10142, 3, 1552, 776,
		0, 10134, 10142, 3, 1564, 782, 0, 10135, 10142, 3, 1572, 786, 0, 10136,
		10142, 3, 1574, 787, 0, 10137, 10142, 3, 1576, 788, 0, 10138, 10142, 3,
		1578, 789, 0, 10139, 10142, 3, 1580, 790, 0, 10140, 10142, 3, 1584, 792,
		0, 10141, 10114, 1, 0, 0, 0, 10141, 10117, 1, 0, 0, 0, 10141, 10118, 1,
		0, 0, 0, 10141, 10119, 1, 0, 0, 0, 10141, 10120, 1, 0, 0, 0, 10141, 10121,
		1, 0, 0, 0, 10141, 10122, 1, 0, 0, 0, 10141, 10123, 1, 0, 0, 0, 10141,
		10124, 1, 0, 0, 0, 10141, 10125, 1, 0, 0, 0, 10141, 10126, 1, 0, 0, 0,
		10141, 10127, 1, 0, 0, 0, 10141, 10128, 1, 0, 0, 0, 10141, 10129, 1, 0,
		0, 0, 10141, 10130, 1, 0, 0, 0, 10141, 10131, 1, 0, 0, 0, 10141, 10132,
		1, 0, 0, 0, 10141, 10133, 1, 0, 0, 0, 10141, 10134, 1, 0, 0, 0, 10141,
		10135, 1, 0, 0, 0, 10141, 10136, 1, 0, 0, 0, 10141, 10137, 1, 0, 0, 0,
		10141, 10138, 1, 0, 0, 0, 10141, 10139, 1, 0, 0, 0, 10141, 10140, 1, 0,
		0, 0, 10142, 1455, 1, 0, 0, 0, 10143, 10144, 5, 498, 0, 0, 10144, 10145,
		3, 1614, 807, 0, 10145, 10146, 5, 7, 0, 0, 10146, 1457, 1, 0, 0, 0, 10147,
		10148, 5, 433, 0, 0, 10148, 10149, 3, 1606, 803, 0, 10149, 10150, 5, 2,
		0, 0, 10150, 10151, 3, 1460, 730, 0, 10151, 10152, 5, 3, 0, 0, 10152, 10153,
		5, 7, 0, 0, 10153, 10162, 1, 0, 0, 0, 10154, 10155, 5, 57, 0, 0, 10155,
		10156, 3, 1606, 803, 0, 10156, 10157, 5, 2, 0, 0, 10157, 10158, 3, 1460,
		730, 0, 10158, 10159, 5, 3, 0, 0, 10159, 10160, 5, 7, 0, 0, 10160, 10162,
		1, 0, 0, 0, 10161, 10147, 1, 0, 0, 0, 10161, 10154, 1, 0, 0, 0, 10162,
		1459, 1, 0, 0, 0, 10163, 10166, 1, 0, 0, 0, 10164, 10166, 3, 1280, 640,
		0, 10165, 10163, 1, 0, 0, 0, 10165, 10164, 1, 0, 0, 0, 10166, 1461, 1,
		0, 0, 0, 10167, 10168, 3, 1476, 738, 0, 10168, 10169, 3, 1450, 725, 0,
		10169, 10170, 3, 1610, 805, 0, 10170, 10171, 5, 7, 0, 0, 10171, 1463, 1,
		0, 0, 0, 10172, 10173, 5, 499, 0, 0, 10173, 10174, 3, 1466, 733, 0, 10174,
		10175, 5, 500, 0, 0, 10175, 10176, 3, 1468, 734, 0, 10176, 10177, 5, 7,
		0, 0, 10177, 1465, 1, 0, 0, 0, 10178, 10182, 1, 0, 0, 0, 10179, 10182,
		5, 434, 0, 0, 10180, 10182, 5, 501, 0, 0, 10181, 10178, 1, 0, 0, 0, 10181,
		10179, 1, 0, 0, 0, 10181, 10180, 1, 0, 0, 0, 10182, 1467, 1, 0, 0, 0, 10183,
		10188, 3, 1470, 735, 0, 10184, 10185, 5, 6, 0, 0, 10185, 10187, 3, 1470,
		735, 0, 10186, 10184, 1, 0, 0, 0, 10187, 10190, 1, 0, 0, 0, 10188, 10186,
		1, 0, 0, 0, 10188, 10189, 1, 0, 0, 0, 10189, 1469, 1, 0, 0, 0, 10190, 10188,
		1, 0, 0, 0, 10191, 10192, 3, 1474, 737, 0, 10192, 10193, 3, 1450, 725,
		0, 10193, 10194, 3, 1472, 736, 0, 10194, 1471, 1, 0, 0, 0, 10195, 10196,
		3, 1372, 686, 0, 10196, 1473, 1, 0, 0, 0, 10197, 10198, 3, 1476, 738, 0,
		10198, 1475, 1, 0, 0, 0, 10199, 10202, 3, 524, 262, 0, 10200, 10202, 5,
		28, 0, 0, 10201, 10199, 1, 0, 0, 0, 10201, 10200, 1, 0, 0, 0, 10202, 10209,
		1, 0, 0, 0, 10203, 10204, 5, 4, 0, 0, 10204, 10205, 3, 1616, 808, 0, 10205,
		10206, 5, 5, 0, 0, 10206, 10208, 1, 0, 0, 0, 10207, 10203, 1, 0, 0, 0,
		10208, 10211, 1, 0, 0, 0, 10209, 10207, 1, 0, 0, 0, 10209, 10210, 1, 0,
		0, 0, 10210, 1477, 1, 0, 0, 0, 10211, 10209, 1, 0, 0, 0, 10212, 10213,
		5, 220, 0, 0, 10213, 10214, 3, 1612, 806, 0, 10214, 10215, 5, 93, 0, 0,
		10215, 10216, 3, 1452, 726, 0, 10216, 10217, 3, 1480, 740, 0, 10217, 10218,
		3, 1482, 741, 0, 10218, 10219, 5, 454, 0, 0, 10219, 10220, 5, 220, 0, 0,
		10220, 10221, 5, 7, 0, 0, 10221, 1479, 1, 0, 0, 0, 10222, 10223, 5, 502,
		0, 0, 10223, 10224, 3, 1162, 581, 0, 10224, 10225, 5, 93, 0, 0, 10225,
		10226, 3, 1452, 726, 0, 10226, 10228, 1, 0, 0, 0, 10227, 10222, 1, 0, 0,
		0, 10228, 10231, 1, 0, 0, 0, 10229, 10227, 1, 0, 0, 0, 10229, 10230, 1,
		0, 0, 0, 10230, 1481, 1, 0, 0, 0, 10231, 10229, 1, 0, 0, 0, 10232, 10236,
		1, 0, 0, 0, 10233, 10234, 5, 58, 0, 0, 10234, 10236, 3, 1452, 726, 0, 10235,
		10232, 1, 0, 0, 0, 10235, 10233, 1, 0, 0, 0, 10236, 1483, 1, 0, 0, 0, 10237,
		10238, 5, 40, 0, 0, 10238, 10239, 3, 1486, 743, 0, 10239, 10240, 3, 1488,
		744, 0, 10240, 10241, 3, 1492, 746, 0, 10241, 10242, 5, 454, 0, 0, 10242,
		10243, 5, 40, 0, 0, 10243, 10244, 5, 7, 0, 0, 10244, 1485, 1, 0, 0, 0,
		10245, 10248, 1, 0, 0, 0, 10246, 10248, 3, 1610, 805, 0, 10247, 10245,
		1, 0, 0, 0, 10247, 10246, 1, 0, 0, 0, 10248, 1487, 1, 0, 0, 0, 10249, 10251,
		3, 1490, 745, 0, 10250, 10249, 1, 0, 0, 0, 10251, 10252, 1, 0, 0, 0, 10252,
		10250, 1, 0, 0, 0, 10252, 10253, 1, 0, 0, 0, 10253, 1489, 1, 0, 0, 0, 10254,
		10255, 5, 102, 0, 0, 10255, 10256, 3, 1280, 640, 0, 10256, 10257, 5, 93,
		0, 0, 10257, 10258, 3, 1452, 726, 0, 10258, 1491, 1, 0, 0, 0, 10259, 10263,
		1, 0, 0, 0, 10260, 10261, 5, 58, 0, 0, 10261, 10263, 3, 1452, 726, 0, 10262,
		10259, 1, 0, 0, 0, 10262, 10260, 1, 0, 0, 0, 10263, 1493, 1, 0, 0, 0, 10264,
		10265, 3, 1600, 800, 0, 10265, 10266, 3, 1540, 770, 0, 10266, 1495, 1,
		0, 0, 0, 10267, 10268, 3, 1600, 800, 0, 10268, 10269, 5, 503, 0, 0, 10269,
		10270, 3, 1618, 809, 0, 10270, 10271, 3, 1540, 770, 0, 10271, 1497, 1,
		0, 0, 0, 10272, 10273, 3, 1600, 800, 0, 10273, 10274, 5, 62, 0, 0, 10274,
		10275, 3, 1500, 750, 0, 10275, 10276, 3, 1540, 770, 0, 10276, 1499, 1,
		0, 0, 0, 10277, 10278, 3, 1510, 755, 0, 10278, 10294, 5, 68, 0, 0, 10279,
		10280, 3, 954, 477, 0, 10280, 10281, 3, 1504, 752, 0, 10281, 10295, 1,
		0, 0, 0, 10282, 10295, 3, 960, 480, 0, 10283, 10295, 3, 878, 439, 0, 10284,
		10285, 5, 202, 0, 0, 10285, 10286, 3, 1162, 581, 0, 10286, 10287, 3, 1502,
		751, 0, 10287, 10295, 1, 0, 0, 0, 10288, 10289, 3, 1506, 753, 0, 10289,
		10290, 3, 1162, 581, 0, 10290, 10291, 5, 24, 0, 0, 10291, 10292, 3, 1162,
		581, 0, 10292, 10293, 3, 1508, 754, 0, 10293, 10295, 1, 0, 0, 0, 10294,
		10279, 1, 0, 0, 0, 10294, 10282, 1, 0, 0, 0, 10294, 10283, 1, 0, 0, 0,
		10294, 10284, 1, 0, 0, 0, 10294, 10288, 1, 0, 0, 0, 10295, 1501, 1, 0,
		0, 0, 10296, 10300, 1, 0, 0, 0, 10297, 10298, 5, 100, 0, 0, 10298, 10300,
		3, 1280, 640, 0, 10299, 10296, 1, 0, 0, 0, 10299, 10297, 1, 0, 0, 0, 10300,
		1503, 1, 0, 0, 0, 10301, 10314, 1, 0, 0, 0, 10302, 10303, 5, 2, 0, 0, 10303,
		10308, 3, 1162, 581, 0, 10304, 10305, 5, 6, 0, 0, 10305, 10307, 3, 1162,
		581, 0, 10306, 10304, 1, 0, 0, 0, 10307, 10310, 1, 0, 0, 0, 10308, 10306,
		1, 0, 0, 0, 10308, 10309, 1, 0, 0, 0, 10309, 10311, 1, 0, 0, 0, 10310,
		10308, 1, 0, 0, 0, 10311, 10312, 5, 3, 0, 0, 10312, 10314, 1, 0, 0, 0,
		10313, 10301, 1, 0, 0, 0, 10313, 10302, 1, 0, 0, 0, 10314, 1505, 1, 0,
		0, 0, 10315, 10318, 1, 0, 0, 0, 10316, 10318, 5, 504, 0, 0, 10317, 10315,
		1, 0, 0, 0, 10317, 10316, 1, 0, 0, 0, 10318, 1507, 1, 0, 0, 0, 10319, 10323,
		1, 0, 0, 0, 10320, 10321, 5, 147, 0, 0, 10321, 10323, 3, 1162, 581, 0,
		10322, 10319, 1, 0, 0, 0, 10322, 10320, 1, 0, 0, 0, 10323, 1509, 1, 0,
		0, 0, 10324, 10325, 3, 522, 261, 0, 10325, 1511, 1, 0, 0, 0, 10326, 10327,
		3, 1600, 800, 0, 10327, 10328, 5, 505, 0, 0, 10328, 10329, 3, 1510, 755,
		0, 10329, 10330, 3, 1514, 757, 0, 10330, 10331, 5, 68, 0, 0, 10331, 10332,
		5, 35, 0, 0, 10332, 10333, 3, 1162, 581, 0, 10333, 10334, 3, 1540, 770,
		0, 10334, 1513, 1, 0, 0, 0, 10335, 10339, 1, 0, 0, 0, 10336, 10337, 5,
		506, 0, 0, 10337, 10339, 3, 1356, 678, 0, 10338, 10335, 1, 0, 0, 0, 10338,
		10336, 1, 0, 0, 0, 10339, 1515, 1, 0, 0, 0, 10340, 10341, 3, 1518, 759,
		0, 10341, 10342, 3, 1602, 801, 0, 10342, 10343, 3, 1604, 802, 0, 10343,
		10344, 5, 7, 0, 0, 10344, 1517, 1, 0, 0, 0, 10345, 10346, 7, 66, 0, 0,
		10346, 1519, 1, 0, 0, 0, 10347, 10359, 5, 508, 0, 0, 10348, 10349, 5, 261,
		0, 0, 10349, 10360, 3, 1610, 805, 0, 10350, 10356, 5, 509, 0, 0, 10351,
		10352, 5, 202, 0, 0, 10352, 10353, 3, 1162, 581, 0, 10353, 10354, 3, 1502,
		751, 0, 10354, 10357, 1, 0, 0, 0, 10355, 10357, 3, 960, 480, 0, 10356,
		10351, 1, 0, 0, 0, 10356, 10355, 1, 0, 0, 0, 10357, 10360, 1, 0, 0, 0,
		10358, 10360, 3, 1522, 761, 0, 10359, 10348, 1, 0, 0, 0, 10359, 10350,
		1, 0, 0, 0, 10359, 10358, 1, 0, 0, 0, 10360, 10361, 1, 0, 0, 0, 10361,
		10362, 5, 7, 0, 0, 10362, 1521, 1, 0, 0, 0, 10363, 10366, 1, 0, 0, 0, 10364,
		10366, 3, 1610, 805, 0, 10365, 10363, 1, 0, 0, 0, 10365, 10364, 1, 0, 0,
		0, 10366, 1523, 1, 0, 0, 0, 10367, 10368, 5, 510, 0, 0, 10368, 10369, 3,
		1526, 763, 0, 10369, 10370, 3, 1358, 679, 0, 10370, 10371, 3, 1528, 764,
		0, 10371, 10372, 3, 1530, 765, 0, 10372, 10373, 5, 7, 0, 0, 10373, 10394,
		1, 0, 0, 0, 10374, 10375, 5, 510, 0, 0, 10375, 10376, 3, 1526, 763, 0,
		10376, 10377, 3, 1382, 691, 0, 10377, 10378, 3, 1530, 765, 0, 10378, 10379,
		5, 7, 0, 0, 10379, 10394, 1, 0, 0, 0, 10380, 10381, 5, 510, 0, 0, 10381,
		10382, 3, 1526, 763, 0, 10382, 10383, 5, 511, 0, 0, 10383, 10384, 3, 1358,
		679, 0, 10384, 10385, 3, 1530, 765, 0, 10385, 10386, 5, 7, 0, 0, 10386,
		10394, 1, 0, 0, 0, 10387, 10388, 5, 510, 0, 0, 10388, 10389, 3, 1526, 763,
		0, 10389, 10390, 3, 1530, 765, 0, 10390, 10391, 5, 7, 0, 0, 10391, 10394,
		1, 0, 0, 0, 10392, 10394, 5, 510, 0, 0, 10393, 10367, 1, 0, 0, 0, 10393,
		10374, 1, 0, 0, 0, 10393, 10380, 1, 0, 0, 0, 10393, 10387, 1, 0, 0, 0,
		10393, 10392, 1, 0, 0, 0, 10394, 1525, 1, 0, 0, 0, 10395, 10404, 1, 0,
		0, 0, 10396, 10404, 1, 0, 0, 0, 10397, 10404, 5, 512, 0, 0, 10398, 10404,
		5, 513, 0, 0, 10399, 10404, 5, 514, 0, 0, 10400, 10404, 5, 515, 0, 0, 10401,
		10404, 5, 516, 0, 0, 10402, 10404, 5, 517, 0, 0, 10403, 10395, 1, 0, 0,
		0, 10403, 10396, 1, 0, 0, 0, 10403, 10397, 1, 0, 0, 0, 10403, 10398, 1,
		0, 0, 0, 10403, 10399, 1, 0, 0, 0, 10403, 10400, 1, 0, 0, 0, 10403, 10401,
		1, 0, 0, 0, 10403, 10402, 1, 0, 0, 0, 10404, 1527, 1, 0, 0, 0, 10405, 10413,
		1, 0, 0, 0, 10406, 10407, 5, 6, 0, 0, 10407, 10409, 3, 1162, 581, 0, 10408,
		10406, 1, 0, 0, 0, 10409, 10410, 1, 0, 0, 0, 10410, 10408, 1, 0, 0, 0,
		10410, 10411, 1, 0, 0, 0, 10411, 10413, 1, 0, 0, 0, 10412, 10405, 1, 0,
		0, 0, 10412, 10408, 1, 0, 0, 0, 10413, 1529, 1, 0, 0, 0, 10414, 10418,
		1, 0, 0, 0, 10415, 10416, 5, 100, 0, 0, 10416, 10418, 3, 1534, 767, 0,
		10417, 10414, 1, 0, 0, 0, 10417, 10415, 1, 0, 0, 0, 10418, 1531, 1, 0,
		0, 0, 10419, 10420, 3, 1382, 691, 0, 10420, 10421, 5, 10, 0, 0, 10421,
		10422, 3, 1162, 581, 0, 10422, 1533, 1, 0, 0, 0, 10423, 10428, 3, 1532,
		766, 0, 10424, 10425, 5, 6, 0, 0, 10425, 10427, 3, 1532, 766, 0, 10426,
		10424, 1, 0, 0, 0, 10427, 10430, 1, 0, 0, 0, 10428, 10426, 1, 0, 0, 0,
		10428, 10429, 1, 0, 0, 0, 10429, 1535, 1, 0, 0, 0, 10430, 10428, 1, 0,
		0, 0, 10431, 10432, 5, 518, 0, 0, 10432, 10433, 3, 1610, 805, 0, 10433,
		10434, 3, 1538, 769, 0, 10434, 10435, 5, 7, 0, 0, 10435, 1537, 1, 0, 0,
		0, 10436, 10440, 1, 0, 0, 0, 10437, 10438, 5, 6, 0, 0, 10438, 10440, 3,
		1610, 805, 0, 10439, 10436, 1, 0, 0, 0, 10439, 10437, 1, 0, 0, 0, 10440,
		1539, 1, 0, 0, 0, 10441, 10442, 5, 519, 0, 0, 10442, 10443, 3, 1452, 726,
		0, 10443, 10444, 5, 454, 0, 0, 10444, 10445, 5, 519, 0, 0, 10445, 10446,
		3, 1602, 801, 0, 10446, 10447, 5, 7, 0, 0, 10447, 1541, 1, 0, 0, 0, 10448,
		10449, 3, 1620, 810, 0, 10449, 10450, 5, 7, 0, 0, 10450, 1543, 1, 0, 0,
		0, 10451, 10452, 5, 202, 0, 0, 10452, 10460, 3, 1162, 581, 0, 10453, 10454,
		3, 1550, 775, 0, 10454, 10455, 3, 1546, 773, 0, 10455, 10461, 1, 0, 0,
		0, 10456, 10457, 3, 1546, 773, 0, 10457, 10458, 3, 1550, 775, 0, 10458,
		10461, 1, 0, 0, 0, 10459, 10461, 1, 0, 0, 0, 10460, 10453, 1, 0, 0, 0,
		10460, 10456, 1, 0, 0, 0, 10460, 10459, 1, 0, 0, 0, 10461, 10462, 1, 0,
		0, 0, 10462, 10463, 5, 7, 0, 0, 10463, 1545, 1, 0, 0, 0, 10464, 10468,
		1, 0, 0, 0, 10465, 10466, 5, 100, 0, 0, 10466, 10468, 3, 1548, 774, 0,
		10467, 10464, 1, 0, 0, 0, 10467, 10465, 1, 0, 0, 0, 10468, 1547, 1, 0,
		0, 0, 10469, 10474, 3, 1162, 581, 0, 10470, 10471, 5, 6, 0, 0, 10471, 10473,
		3, 1162, 581, 0, 10472, 10470, 1, 0, 0, 0, 10473, 10476, 1, 0, 0, 0, 10474,
		10472, 1, 0, 0, 0, 10474, 10475, 1, 0, 0, 0, 10475, 1549, 1, 0, 0, 0, 10476,
		10474, 1, 0, 0, 0, 10477, 10484, 1, 0, 0, 0, 10478, 10480, 5, 71, 0, 0,
		10479, 10481, 5, 339, 0, 0, 10480, 10479, 1, 0, 0, 0, 10480, 10481, 1,
		0, 0, 0, 10481, 10482, 1, 0, 0, 0, 10482, 10484, 3, 1566, 783, 0, 10483,
		10477, 1, 0, 0, 0, 10483, 10478, 1, 0, 0, 0, 10484, 1551, 1, 0, 0, 0, 10485,
		10503, 5, 520, 0, 0, 10486, 10487, 3, 1586, 793, 0, 10487, 10488, 3, 1560,
		780, 0, 10488, 10494, 5, 62, 0, 0, 10489, 10495, 3, 960, 480, 0, 10490,
		10491, 5, 202, 0, 0, 10491, 10492, 3, 1610, 805, 0, 10492, 10493, 3, 1558,
		779, 0, 10493, 10495, 1, 0, 0, 0, 10494, 10489, 1, 0, 0, 0, 10494, 10490,
		1, 0, 0, 0, 10495, 10504, 1, 0, 0, 0, 10496, 10501, 3, 1372, 686, 0, 10497,
		10498, 5, 2, 0, 0, 10498, 10499, 3, 1556, 778, 0, 10499, 10500, 5, 3, 0,
		0, 10500, 10502, 1, 0, 0, 0, 10501, 10497, 1, 0, 0, 0, 10501, 10502, 1,
		0, 0, 0, 10502, 10504, 1, 0, 0, 0, 10503, 10486, 1, 0, 0, 0, 10503, 10496,
		1, 0, 0, 0, 10504, 10505, 1, 0, 0, 0, 10505, 10506, 5, 7, 0, 0, 10506,
		1553, 1, 0, 0, 0, 10507, 10508, 3, 1372, 686, 0, 10508, 10509, 5, 20, 0,
		0, 10509, 10510, 3, 1162, 581, 0, 10510, 10513, 1, 0, 0, 0, 10511, 10513,
		3, 1162, 581, 0, 10512, 10507, 1, 0, 0, 0, 10512, 10511, 1, 0, 0, 0, 10513,
		1555, 1, 0, 0, 0, 10514, 10519, 3, 1554, 777, 0, 10515, 10516, 5, 6, 0,
		0, 10516, 10518, 3, 1554, 777, 0, 10517, 10515, 1, 0, 0, 0, 10518, 10521,
		1, 0, 0, 0, 10519, 10517, 1, 0, 0, 0, 10519, 10520, 1, 0, 0, 0, 10520,
		1557, 1, 0, 0, 0, 10521, 10519, 1, 0, 0, 0, 10522, 10526, 1, 0, 0, 0, 10523,
		10524, 5, 100, 0, 0, 10524, 10526, 3, 1280, 640, 0, 10525, 10522, 1, 0,
		0, 0, 10525, 10523, 1, 0, 0, 0, 10526, 1559, 1, 0, 0, 0, 10527, 10532,
		1, 0, 0, 0, 10528, 10529, 3, 1562, 781, 0, 10529, 10530, 5, 317, 0, 0,
		10530, 10532, 1, 0, 0, 0, 10531, 10527, 1, 0, 0, 0, 10531, 10528, 1, 0,
		0, 0, 10532, 1561, 1, 0, 0, 0, 10533, 10536, 1, 0, 0, 0, 10534, 10536,
		5, 262, 0, 0, 10535, 10533, 1, 0, 0, 0, 10535, 10534, 1, 0, 0, 0, 10536,
		1563, 1, 0, 0, 0, 10537, 10538, 5, 61, 0, 0, 10538, 10539, 3, 1570, 785,
		0, 10539, 10540, 3, 1568, 784, 0, 10540, 10541, 3, 1586, 793, 0, 10541,
		10542, 5, 71, 0, 0, 10542, 10543, 3, 1566, 783, 0, 10543, 10544, 5, 7,
		0, 0, 10544, 1565, 1, 0, 0, 0, 10545, 10546, 3, 1280, 640, 0, 10546, 1567,
		1, 0, 0, 0, 10547, 10551, 1, 0, 0, 0, 10548, 10551, 5, 64, 0, 0, 10549,
		10551, 5, 68, 0, 0, 10550, 10547, 1, 0, 0, 0, 10550, 10548, 1, 0, 0, 0,
		10550, 10549, 1, 0, 0, 0, 10551, 1569, 1, 0, 0, 0, 10552, 10570, 1, 0,
		0, 0, 10553, 10570, 1, 0, 0, 0, 10554, 10570, 5, 261, 0, 0, 10555, 10570,
		5, 286, 0, 0, 10556, 10570, 5, 207, 0, 0, 10557, 10570, 5, 240, 0, 0, 10558,
		10559, 5, 130, 0, 0, 10559, 10570, 3, 1162, 581, 0, 10560, 10561, 5, 300,
		0, 0, 10561, 10570, 3, 1162, 581, 0, 10562, 10570, 3, 1162, 581, 0, 10563,
		10570, 5, 30, 0, 0, 10564, 10567, 7, 67, 0, 0, 10565, 10568, 3, 1162, 581,
		0, 10566, 10568, 5, 30, 0, 0, 10567, 10565, 1, 0, 0, 0, 10567, 10566, 1,
		0, 0, 0, 10567, 10568, 1, 0, 0, 0, 10568, 10570, 1, 0, 0, 0, 10569, 10552,
		1, 0, 0, 0, 10569, 10553, 1, 0, 0, 0, 10569, 10554, 1, 0, 0, 0, 10569,
		10555, 1, 0, 0, 0, 10569, 10556, 1, 0, 0, 0, 10569, 10557, 1, 0, 0, 0,
		10569, 10558, 1, 0, 0, 0, 10569, 10560, 1, 0, 0, 0, 10569, 10562, 1, 0,
		0, 0, 10569, 10563, 1, 0, 0, 0, 10569, 10564, 1, 0, 0, 0, 10570, 1571,
		1, 0, 0, 0, 10571, 10572, 5, 258, 0, 0, 10572, 10573, 3, 1570, 785, 0,
		10573, 10574, 3, 1586, 793, 0, 10574, 10575, 5, 7, 0, 0, 10575, 1573, 1,
		0, 0, 0, 10576, 10577, 5, 157, 0, 0, 10577, 10578, 3, 1586, 793, 0, 10578,
		10579, 5, 7, 0, 0, 10579, 1575, 1, 0, 0, 0, 10580, 10581, 5, 78, 0, 0,
		10581, 10582, 5, 7, 0, 0, 10582, 1577, 1, 0, 0, 0, 10583, 10584, 5, 161,
		0, 0, 10584, 10585, 3, 1582, 791, 0, 10585, 10586, 5, 7, 0, 0, 10586, 1579,
		1, 0, 0, 0, 10587, 10588, 5, 312, 0, 0, 10588, 10589, 3, 1582, 791, 0,
		10589, 10590, 5, 7, 0, 0, 10590, 1581, 1, 0, 0, 0, 10591, 10593, 5, 33,
		0, 0, 10592, 10594, 5, 262, 0, 0, 10593, 10592, 1, 0, 0, 0, 10593, 10594,
		1, 0, 0, 0, 10594, 10595, 1, 0, 0, 0, 10595, 10598, 5, 153, 0, 0, 10596,
		10598, 1, 0, 0, 0, 10597, 10591, 1, 0, 0, 0, 10597, 10596, 1, 0, 0, 0,
		10598, 1583, 1, 0, 0, 0, 10599, 10600, 5, 326, 0, 0, 10600, 10601, 3, 524,
		262, 0, 10601, 10602, 5, 94, 0, 0, 10602, 10603, 5, 53, 0, 0, 10603, 10604,
		5, 7, 0, 0, 10604, 10612, 1, 0, 0, 0, 10605, 10608, 5, 306, 0, 0, 10606,
		10609, 3, 524, 262, 0, 10607, 10609, 5, 30, 0, 0, 10608, 10606, 1, 0, 0,
		0, 10608, 10607, 1, 0, 0, 0, 10609, 10610, 1, 0, 0, 0, 10610, 10612, 5,
		7, 0, 0, 10611, 10599, 1, 0, 0, 0, 10611, 10605, 1, 0, 0, 0, 10612, 1585,
		1, 0, 0, 0, 10613, 10616, 3, 1372, 686, 0, 10614, 10616, 5, 28, 0, 0, 10615,
		10613, 1, 0, 0, 0, 10615, 10614, 1, 0, 0, 0, 10616, 1587, 1, 0, 0, 0, 10617,
		10621, 1, 0, 0, 0, 10618, 10619, 5, 517, 0, 0, 10619, 10621, 3, 1590, 795,
		0, 10620, 10617, 1, 0, 0, 0, 10620, 10618, 1, 0, 0, 0, 10621, 1589, 1,
		0, 0, 0, 10622, 10624, 3, 1592, 796, 0, 10623, 10622, 1, 0, 0, 0, 10624,
		10625, 1, 0, 0, 0, 10625, 10623, 1, 0, 0, 0, 10625, 10626, 1, 0, 0, 0,
		10626, 1591, 1, 0, 0, 0, 10627, 10628, 5, 102, 0, 0, 10628, 10629, 3, 1594,
		797, 0, 10629, 10630, 5, 93, 0, 0, 10630, 10631, 3, 1452, 726, 0, 10631,
		1593, 1, 0, 0, 0, 10632, 10637, 3, 1596, 798, 0, 10633, 10634, 5, 82, 0,
		0, 10634, 10636, 3, 1596, 798, 0, 10635, 10633, 1, 0, 0, 0, 10636, 10639,
		1, 0, 0, 0, 10637, 10635, 1, 0, 0, 0, 10637, 10638, 1, 0, 0, 0, 10638,
		1595, 1, 0, 0, 0, 10639, 10637, 1, 0, 0, 0, 10640, 10644, 3, 1606, 803,
		0, 10641, 10642, 5, 511, 0, 0, 10642, 10644, 3, 1358, 679, 0, 10643, 10640,
		1, 0, 0, 0, 10643, 10641, 1, 0, 0, 0, 10644, 1597, 1, 0, 0, 0, 10645, 10648,
		1, 0, 0, 0, 10646, 10648, 3, 1416, 708, 0, 10647, 10645, 1, 0, 0, 0, 10647,
		10646, 1, 0, 0, 0, 10648, 1599, 1, 0, 0, 0, 10649, 10652, 1, 0, 0, 0, 10650,
		10652, 3, 1416, 708, 0, 10651, 10649, 1, 0, 0, 0, 10651, 10650, 1, 0, 0,
		0, 10652, 1601, 1, 0, 0, 0, 10653, 10656, 1, 0, 0, 0, 10654, 10656, 3,
		1606, 803, 0, 10655, 10653, 1, 0, 0, 0, 10655, 10654, 1, 0, 0, 0, 10656,
		1603, 1, 0, 0, 0, 10657, 10658, 5, 102, 0, 0, 10658, 10661, 3, 1614, 807,
		0, 10659, 10661, 1, 0, 0, 0, 10660, 10657, 1, 0, 0, 0, 10660, 10659, 1,
		0, 0, 0, 10661, 1605, 1, 0, 0, 0, 10662, 10665, 3, 1372, 686, 0, 10663,
		10665, 3, 1608, 804, 0, 10664, 10662, 1, 0, 0, 0, 10664, 10663, 1, 0, 0,
		0, 10665, 1607, 1, 0, 0, 0, 10666, 10667, 7, 68, 0, 0, 10667, 1609, 1,
		0, 0, 0, 10668, 10669, 3, 1328, 664, 0, 10669, 10670, 3, 982, 491, 0, 10670,
		10671, 3, 1054, 527, 0, 10671, 10672, 3, 1094, 547, 0, 10672, 10673, 3,
		1024, 512, 0, 10673, 10674, 3, 1038, 519, 0, 10674, 10675, 3, 1240, 620,
		0, 10675, 1611, 1, 0, 0, 0, 10676, 10677, 3, 1610, 805, 0, 10677, 1613,
		1, 0, 0, 0, 10678, 10679, 3, 1610, 805, 0, 10679, 1615, 1, 0, 0, 0, 10680,
		10681, 3, 1162, 581, 0, 10681, 1617, 1, 0, 0, 0, 10682, 10683, 3, 1162,
		581, 0, 10683, 1619, 1, 0, 0, 0, 10684, 10685, 3, 8, 4, 0, 10685, 10686,
		3, 1622, 811, 0, 10686, 1621, 1, 0, 0, 0, 10687, 10688, 5, 71, 0, 0, 10688,
		10689, 3, 984, 492, 0, 10689, 10690, 3, 1566, 783, 0, 10690, 10693, 1,
		0, 0, 0, 10691, 10693, 1, 0, 0, 0, 10692, 10687, 1, 0, 0, 0, 10692, 10691,
		1, 0, 0, 0, 10693, 1623, 1, 0, 0, 0, 744, 1633, 1637, 1765, 1769, 1782,
		1787, 1793, 1799, 1814, 1826, 1844, 1849, 1859, 1883, 1890, 1896, 1901,
		1910, 1914, 1926, 1957, 1964, 1972, 1977, 1984, 1990, 2007, 2012, 2016,
		2029, 2033, 2038, 2043, 2055, 2064, 2077, 2082, 2093, 2104, 2109, 2120,
		2131, 2140, 2150, 2165, 2177, 2182, 2189, 2200, 2458, 2465, 2470, 2475,
		2480, 2488, 2497, 2504, 2514, 2516, 2521, 2527, 2533, 2535, 2563, 2573,
		2586, 2598, 2612, 2617, 2641, 2647, 2652, 2659, 2664, 2702, 2706, 2713,
		2717, 2724, 2738, 2745, 2756, 2789, 2799, 2803, 2810, 2817, 2825, 2831,
		2835, 2845, 2852, 2863, 2895, 2903, 2908, 2915, 2925, 2935, 2955, 2970,
		2995, 3000, 3007, 3014, 3025, 3030, 3037, 3048, 3056, 3067, 3083, 3091,
		3095, 3109, 3126, 3131, 3138, 3147, 3150, 3155, 3162, 3173, 3186, 3199,
		3217, 3220, 3229, 3244, 3259, 3268, 3275, 3282, 3287, 3317, 3319, 3323,
		3331, 3338, 3352, 3356, 3360, 3365, 3371, 3375, 3379, 3392, 3398, 3407,
		3416, 3426, 3437, 3547, 3565, 3570, 3574, 3591, 3599, 3606, 3619, 3629,
		3663, 3668, 3673, 3677, 3685, 3687, 3745, 3762, 3770, 3793, 3797, 3817,
		3854, 3863, 3868, 3873, 3878, 3883, 3936, 3942, 3949, 3959, 3964, 3969,
		3987, 3991, 4001, 4007, 4013, 4020, 4025, 4030, 4044, 4072, 4079, 4093,
		4108, 4225, 4236, 4242, 4250, 4261, 4270, 4277, 4317, 4323, 4344, 4372,
		4376, 4381, 4390, 4394, 4421, 4428, 4443, 4463, 4483, 4576, 4601, 4608,
		4624, 4633, 4638, 4644, 4651, 4665, 4814, 4818, 4911, 4916, 4920, 4926,
		4994, 5000, 5029, 5046, 5053, 5065, 5125, 5132, 5138, 5144, 5170, 5176,
		5182, 5193, 5205, 5234, 5273, 5277, 5281, 5285, 5290, 5297, 5311, 5324,
		5332, 5339, 5345, 5349, 5354, 5361, 5375, 5377, 5384, 5388, 5397, 5405,
		5414, 5416, 5420, 5429, 5434, 5440, 5445, 5449, 5454, 5460, 5466, 5472,
		5478, 5483, 5498, 5507, 5518, 5524, 5563, 5573, 5580, 5591, 5597, 5607,
		5619, 5623, 5661, 5675, 5689, 5713, 5720, 5730, 5742, 5747, 5783, 5790,
		5805, 5852, 5889, 5900, 5917, 6387, 6391, 6396, 6455, 6459, 6678, 6693,
		6704, 6711, 6904, 6914, 6922, 6951, 6967, 7009, 7023, 7045, 7052, 7060,
		7064, 7071, 7080, 7089, 7141, 7146, 7158, 7162, 7167, 7172, 7176, 7180,
		7185, 7201, 7209, 7214, 7227, 7232, 7239, 7249, 7253, 7264, 7275, 7283,
		7290, 7329, 7337, 7341, 7422, 7450, 7455, 7470, 7482, 7489, 7499, 7504,
		7508, 7512, 7516, 7520, 7527, 7537, 7542, 7560, 7571, 7578, 7586, 7591,
		7604, 7610, 7639, 7646, 7658, 7671, 7686, 7692, 7701, 7717, 7720, 7731,
		7736, 7740, 7744, 7749, 7752, 7758, 7762, 7764, 7767, 7774, 7777, 7784,
		7792, 7795, 7804, 7819, 7832, 7843, 7846, 7850, 7856, 7872, 7885, 7895,
		7913, 7915, 7923, 7927, 7937, 7947, 7958, 7960, 7969, 7979, 7990, 8003,
		8007, 8016, 8031, 8035, 8042, 8045, 8049, 8052, 8065, 8069, 8074, 8082,
		8086, 8090, 8101, 8108, 8114, 8118, 8120, 8124, 8130, 8139, 8145, 8147,
		8149, 8156, 8160, 8169, 8173, 8183, 8190, 8198, 8222, 8228, 8232, 8237,
		8246, 8250, 8253, 8258, 8271, 8277, 8285, 8288, 8295, 8300, 8321, 8330,
		8335, 8341, 8346, 8353, 8358, 8364, 8366, 8370, 8377, 8381, 8384, 8391,
		8396, 8399, 8406, 8410, 8419, 8423, 8431, 8433, 8440, 8445, 8448, 8463,
		8475, 8485, 8494, 8499, 8504, 8511, 8514, 8518, 8525, 8549, 8558, 8564,
		8568, 8573, 8583, 8590, 8599, 8602, 8611, 8613, 8619, 8623, 8628, 8642,
		8644, 8650, 8656, 8659, 8668, 8686, 8693, 8697, 8701, 8717, 8724, 8732,
		8736, 8743, 8756, 8772, 8778, 8784, 8791, 8796, 8802, 8809, 8817, 8825,
		8830, 8834, 8840, 8844, 8848, 8851, 8857, 8862, 8878, 8881, 8883, 8895,
		8897, 8901, 8907, 8912, 8920, 8924, 8933, 8941, 8947, 8950, 8959, 8964,
		8971, 8981, 9007, 9018, 9020, 9022, 9030, 9053, 9061, 9071, 9085, 9095,
		9099, 9113, 9120, 9127, 9134, 9159, 9188, 9227, 9229, 9257, 9278, 9285,
		9298, 9310, 9316, 9325, 9342, 9354, 9363, 9368, 9375, 9385, 9388, 9399,
		9405, 9420, 9428, 9437, 9446, 9449, 9454, 9463, 9468, 9482, 9492, 9500,
		9514, 9521, 9529, 9537, 9544, 9550, 9559, 9567, 9577, 9588, 9595, 9624,
		9633, 9640, 9651, 9661, 9665, 9669, 9674, 9682, 9686, 9690, 9695, 9700,
		9705, 9712, 9720, 9723, 9730, 9735, 9742, 9758, 9773, 9787, 9792, 9811,
		9816, 9821, 9828, 9835, 9842, 9851, 9857, 9863, 9869, 9877, 9886, 9944,
		9959, 9982, 9990, 9994, 10006, 10008, 10015, 10024, 10042, 10050, 10059,
		10066, 10076, 10082, 10089, 10094, 10100, 10104, 10111, 10141, 10161, 10165,
		10181, 10188, 10201, 10209, 10229, 10235, 10247, 10252, 10262, 10294, 10299,
		10308, 10313, 10317, 10322, 10338, 10356, 10359, 10365, 10393, 10403, 10410,
		10412, 10417, 10428, 10439, 10460, 10467, 10474, 10480, 10483, 10494, 10501,
		10503, 10512, 10519, 10525, 10531, 10535, 10550, 10567, 10569, 10593, 10597,
		10608, 10611, 10615, 10620, 10625, 10637, 10643, 10647, 10651, 10655, 10660,
		10664, 10692,
	}
	deserializer := antlr.NewATNDeserializer(nil)
	staticData.atn = deserializer.Deserialize(staticData.serializedATN)
	atn := staticData.atn
	staticData.decisionToDFA = make([]*antlr.DFA, len(atn.DecisionToState))
	decisionToDFA := staticData.decisionToDFA
	for index, state := range atn.DecisionToState {
		decisionToDFA[index] = antlr.NewDFA(state, index)
	}
}

// PostgreSQLParserInit initializes any static state used to implement PostgreSQLParser. By default the
// static state used to implement the parser is lazily initialized during the first call to
// NewPostgreSQLParser(). You can call this function if you wish to initialize the static state ahead
// of time.
func PostgreSQLParserInit() {
	staticData := &PostgreSQLParserParserStaticData
	staticData.once.Do(postgresqlparserParserInit)
}

// NewPostgreSQLParser produces a new parser instance for the optional input antlr.TokenStream.
func NewPostgreSQLParser(input antlr.TokenStream) *PostgreSQLParser {
	PostgreSQLParserInit()
	this := new(PostgreSQLParser)
	this.BaseParser = antlr.NewBaseParser(input)
	staticData := &PostgreSQLParserParserStaticData
	this.Interpreter = antlr.NewParserATNSimulator(this, staticData.atn, staticData.decisionToDFA, staticData.PredictionContextCache)
	this.RuleNames = staticData.RuleNames
	this.LiteralNames = staticData.LiteralNames
	this.SymbolicNames = staticData.SymbolicNames
	this.GrammarFileName = "PostgreSQLParser.g4"

	return this
}

// Note that '@members' cannot be changed now, but this should have been 'globals'
// If you are looking to have variables for each instance, use '@structmembers'

// PostgreSQLParser tokens.
const (
	PostgreSQLParserEOF                                                   = antlr.TokenEOF
	PostgreSQLParserDollar                                                = 1
	PostgreSQLParserOPEN_PAREN                                            = 2
	PostgreSQLParserCLOSE_PAREN                                           = 3
	PostgreSQLParserOPEN_BRACKET                                          = 4
	PostgreSQLParserCLOSE_BRACKET                                         = 5
	PostgreSQLParserCOMMA                                                 = 6
	PostgreSQLParserSEMI                                                  = 7
	PostgreSQLParserCOLON                                                 = 8
	PostgreSQLParserSTAR                                                  = 9
	PostgreSQLParserEQUAL                                                 = 10
	PostgreSQLParserDOT                                                   = 11
	PostgreSQLParserPLUS                                                  = 12
	PostgreSQLParserMINUS                                                 = 13
	PostgreSQLParserSLASH                                                 = 14
	PostgreSQLParserCARET                                                 = 15
	PostgreSQLParserLT                                                    = 16
	PostgreSQLParserGT                                                    = 17
	PostgreSQLParserLESS_LESS                                             = 18
	PostgreSQLParserGREATER_GREATER                                       = 19
	PostgreSQLParserCOLON_EQUALS                                          = 20
	PostgreSQLParserLESS_EQUALS                                           = 21
	PostgreSQLParserEQUALS_GREATER                                        = 22
	PostgreSQLParserGREATER_EQUALS                                        = 23
	PostgreSQLParserDOT_DOT                                               = 24
	PostgreSQLParserNOT_EQUALS                                            = 25
	PostgreSQLParserTYPECAST                                              = 26
	PostgreSQLParserPERCENT                                               = 27
	PostgreSQLParserPARAM                                                 = 28
	PostgreSQLParserOperator                                              = 29
	PostgreSQLParserALL                                                   = 30
	PostgreSQLParserANALYSE                                               = 31
	PostgreSQLParserANALYZE                                               = 32
	PostgreSQLParserAND                                                   = 33
	PostgreSQLParserANY                                                   = 34
	PostgreSQLParserARRAY                                                 = 35
	PostgreSQLParserAS                                                    = 36
	PostgreSQLParserASC                                                   = 37
	PostgreSQLParserASYMMETRIC                                            = 38
	PostgreSQLParserBOTH                                                  = 39
	PostgreSQLParserCASE                                                  = 40
	PostgreSQLParserCAST                                                  = 41
	PostgreSQLParserCHECK                                                 = 42
	PostgreSQLParserCOLLATE                                               = 43
	PostgreSQLParserCOLUMN                                                = 44
	PostgreSQLParserCONSTRAINT                                            = 45
	PostgreSQLParserCREATE                                                = 46
	PostgreSQLParserCURRENT_CATALOG                                       = 47
	PostgreSQLParserCURRENT_DATE                                          = 48
	PostgreSQLParserCURRENT_ROLE                                          = 49
	PostgreSQLParserCURRENT_TIME                                          = 50
	PostgreSQLParserCURRENT_TIMESTAMP                                     = 51
	PostgreSQLParserCURRENT_USER                                          = 52
	PostgreSQLParserDEFAULT                                               = 53
	PostgreSQLParserDEFERRABLE                                            = 54
	PostgreSQLParserDESC                                                  = 55
	PostgreSQLParserDISTINCT                                              = 56
	PostgreSQLParserDO                                                    = 57
	PostgreSQLParserELSE                                                  = 58
	PostgreSQLParserEXCEPT                                                = 59
	PostgreSQLParserFALSE_P                                               = 60
	PostgreSQLParserFETCH                                                 = 61
	PostgreSQLParserFOR                                                   = 62
	PostgreSQLParserFOREIGN                                               = 63
	PostgreSQLParserFROM                                                  = 64
	PostgreSQLParserGRANT                                                 = 65
	PostgreSQLParserGROUP_P                                               = 66
	PostgreSQLParserHAVING                                                = 67
	PostgreSQLParserIN_P                                                  = 68
	PostgreSQLParserINITIALLY                                             = 69
	PostgreSQLParserINTERSECT                                             = 70
	PostgreSQLParserINTO                                                  = 71
	PostgreSQLParserLATERAL_P                                             = 72
	PostgreSQLParserLEADING                                               = 73
	PostgreSQLParserLIMIT                                                 = 74
	PostgreSQLParserLOCALTIME                                             = 75
	PostgreSQLParserLOCALTIMESTAMP                                        = 76
	PostgreSQLParserNOT                                                   = 77
	PostgreSQLParserNULL_P                                                = 78
	PostgreSQLParserOFFSET                                                = 79
	PostgreSQLParserON                                                    = 80
	PostgreSQLParserONLY                                                  = 81
	PostgreSQLParserOR                                                    = 82
	PostgreSQLParserORDER                                                 = 83
	PostgreSQLParserPLACING                                               = 84
	PostgreSQLParserPRIMARY                                               = 85
	PostgreSQLParserREFERENCES                                            = 86
	PostgreSQLParserRETURNING                                             = 87
	PostgreSQLParserSELECT                                                = 88
	PostgreSQLParserSESSION_USER                                          = 89
	PostgreSQLParserSOME                                                  = 90
	PostgreSQLParserSYMMETRIC                                             = 91
	PostgreSQLParserTABLE                                                 = 92
	PostgreSQLParserTHEN                                                  = 93
	PostgreSQLParserTO                                                    = 94
	PostgreSQLParserTRAILING                                              = 95
	PostgreSQLParserTRUE_P                                                = 96
	PostgreSQLParserUNION                                                 = 97
	PostgreSQLParserUNIQUE                                                = 98
	PostgreSQLParserUSER                                                  = 99
	PostgreSQLParserUSING                                                 = 100
	PostgreSQLParserVARIADIC                                              = 101
	PostgreSQLParserWHEN                                                  = 102
	PostgreSQLParserWHERE                                                 = 103
	PostgreSQLParserWINDOW                                                = 104
	PostgreSQLParserWITH                                                  = 105
	PostgreSQLParserAUTHORIZATION                                         = 106
	PostgreSQLParserBINARY                                                = 107
	PostgreSQLParserCOLLATION                                             = 108
	PostgreSQLParserCONCURRENTLY                                          = 109
	PostgreSQLParserCROSS                                                 = 110
	PostgreSQLParserCURRENT_SCHEMA                                        = 111
	PostgreSQLParserFREEZE                                                = 112
	PostgreSQLParserFULL                                                  = 113
	PostgreSQLParserILIKE                                                 = 114
	PostgreSQLParserINNER_P                                               = 115
	PostgreSQLParserIS                                                    = 116
	PostgreSQLParserISNULL                                                = 117
	PostgreSQLParserJOIN                                                  = 118
	PostgreSQLParserLEFT                                                  = 119
	PostgreSQLParserLIKE                                                  = 120
	PostgreSQLParserNATURAL                                               = 121
	PostgreSQLParserNOTNULL                                               = 122
	PostgreSQLParserOUTER_P                                               = 123
	PostgreSQLParserOVER                                                  = 124
	PostgreSQLParserOVERLAPS                                              = 125
	PostgreSQLParserRIGHT                                                 = 126
	PostgreSQLParserSIMILAR                                               = 127
	PostgreSQLParserVERBOSE                                               = 128
	PostgreSQLParserABORT_P                                               = 129
	PostgreSQLParserABSOLUTE_P                                            = 130
	PostgreSQLParserACCESS                                                = 131
	PostgreSQLParserACTION                                                = 132
	PostgreSQLParserADD_P                                                 = 133
	PostgreSQLParserADMIN                                                 = 134
	PostgreSQLParserAFTER                                                 = 135
	PostgreSQLParserAGGREGATE                                             = 136
	PostgreSQLParserALSO                                                  = 137
	PostgreSQLParserALTER                                                 = 138
	PostgreSQLParserALWAYS                                                = 139
	PostgreSQLParserASSERTION                                             = 140
	PostgreSQLParserASSIGNMENT                                            = 141
	PostgreSQLParserAT                                                    = 142
	PostgreSQLParserATTRIBUTE                                             = 143
	PostgreSQLParserBACKWARD                                              = 144
	PostgreSQLParserBEFORE                                                = 145
	PostgreSQLParserBEGIN_P                                               = 146
	PostgreSQLParserBY                                                    = 147
	PostgreSQLParserCACHE                                                 = 148
	PostgreSQLParserCALLED                                                = 149
	PostgreSQLParserCASCADE                                               = 150
	PostgreSQLParserCASCADED                                              = 151
	PostgreSQLParserCATALOG                                               = 152
	PostgreSQLParserCHAIN                                                 = 153
	PostgreSQLParserCHARACTERISTICS                                       = 154
	PostgreSQLParserCHECKPOINT                                            = 155
	PostgreSQLParserCLASS                                                 = 156
	PostgreSQLParserCLOSE                                                 = 157
	PostgreSQLParserCLUSTER                                               = 158
	PostgreSQLParserCOMMENT                                               = 159
	PostgreSQLParserCOMMENTS                                              = 160
	PostgreSQLParserCOMMIT                                                = 161
	PostgreSQLParserCOMMITTED                                             = 162
	PostgreSQLParserCONFIGURATION                                         = 163
	PostgreSQLParserCONNECTION                                            = 164
	PostgreSQLParserCONSTRAINTS                                           = 165
	PostgreSQLParserCONTENT_P                                             = 166
	PostgreSQLParserCONTINUE_P                                            = 167
	PostgreSQLParserCONVERSION_P                                          = 168
	PostgreSQLParserCOPY                                                  = 169
	PostgreSQLParserCOST                                                  = 170
	PostgreSQLParserCSV                                                   = 171
	PostgreSQLParserCURSOR                                                = 172
	PostgreSQLParserCYCLE                                                 = 173
	PostgreSQLParserDATA_P                                                = 174
	PostgreSQLParserDATABASE                                              = 175
	PostgreSQLParserDAY_P                                                 = 176
	PostgreSQLParserDEALLOCATE                                            = 177
	PostgreSQLParserDECLARE                                               = 178
	PostgreSQLParserDEFAULTS                                              = 179
	PostgreSQLParserDEFERRED                                              = 180
	PostgreSQLParserDEFINER                                               = 181
	PostgreSQLParserDELETE_P                                              = 182
	PostgreSQLParserDELIMITER                                             = 183
	PostgreSQLParserDELIMITERS                                            = 184
	PostgreSQLParserDICTIONARY                                            = 185
	PostgreSQLParserDISABLE_P                                             = 186
	PostgreSQLParserDISCARD                                               = 187
	PostgreSQLParserDOCUMENT_P                                            = 188
	PostgreSQLParserDOMAIN_P                                              = 189
	PostgreSQLParserDOUBLE_P                                              = 190
	PostgreSQLParserDROP                                                  = 191
	PostgreSQLParserEACH                                                  = 192
	PostgreSQLParserENABLE_P                                              = 193
	PostgreSQLParserENCODING                                              = 194
	PostgreSQLParserENCRYPTED                                             = 195
	PostgreSQLParserENUM_P                                                = 196
	PostgreSQLParserESCAPE                                                = 197
	PostgreSQLParserEVENT                                                 = 198
	PostgreSQLParserEXCLUDE                                               = 199
	PostgreSQLParserEXCLUDING                                             = 200
	PostgreSQLParserEXCLUSIVE                                             = 201
	PostgreSQLParserEXECUTE                                               = 202
	PostgreSQLParserEXPLAIN                                               = 203
	PostgreSQLParserEXTENSION                                             = 204
	PostgreSQLParserEXTERNAL                                              = 205
	PostgreSQLParserFAMILY                                                = 206
	PostgreSQLParserFIRST_P                                               = 207
	PostgreSQLParserFOLLOWING                                             = 208
	PostgreSQLParserFORCE                                                 = 209
	PostgreSQLParserFORWARD                                               = 210
	PostgreSQLParserFUNCTION                                              = 211
	PostgreSQLParserFUNCTIONS                                             = 212
	PostgreSQLParserGLOBAL                                                = 213
	PostgreSQLParserGRANTED                                               = 214
	PostgreSQLParserHANDLER                                               = 215
	PostgreSQLParserHEADER_P                                              = 216
	PostgreSQLParserHOLD                                                  = 217
	PostgreSQLParserHOUR_P                                                = 218
	PostgreSQLParserIDENTITY_P                                            = 219
	PostgreSQLParserIF_P                                                  = 220
	PostgreSQLParserIMMEDIATE                                             = 221
	PostgreSQLParserIMMUTABLE                                             = 222
	PostgreSQLParserIMPLICIT_P                                            = 223
	PostgreSQLParserINCLUDING                                             = 224
	PostgreSQLParserINCREMENT                                             = 225
	PostgreSQLParserINDEX                                                 = 226
	PostgreSQLParserINDEXES                                               = 227
	PostgreSQLParserINHERIT                                               = 228
	PostgreSQLParserINHERITS                                              = 229
	PostgreSQLParserINLINE_P                                              = 230
	PostgreSQLParserINSENSITIVE                                           = 231
	PostgreSQLParserINSERT                                                = 232
	PostgreSQLParserINSTEAD                                               = 233
	PostgreSQLParserINVOKER                                               = 234
	PostgreSQLParserISOLATION                                             = 235
	PostgreSQLParserKEY                                                   = 236
	PostgreSQLParserLABEL                                                 = 237
	PostgreSQLParserLANGUAGE                                              = 238
	PostgreSQLParserLARGE_P                                               = 239
	PostgreSQLParserLAST_P                                                = 240
	PostgreSQLParserLEAKPROOF                                             = 241
	PostgreSQLParserLEVEL                                                 = 242
	PostgreSQLParserLISTEN                                                = 243
	PostgreSQLParserLOAD                                                  = 244
	PostgreSQLParserLOCAL                                                 = 245
	PostgreSQLParserLOCATION                                              = 246
	PostgreSQLParserLOCK_P                                                = 247
	PostgreSQLParserMAPPING                                               = 248
	PostgreSQLParserMATCH                                                 = 249
	PostgreSQLParserMATCHED                                               = 250
	PostgreSQLParserMATERIALIZED                                          = 251
	PostgreSQLParserMAXVALUE                                              = 252
	PostgreSQLParserMERGE                                                 = 253
	PostgreSQLParserMINUTE_P                                              = 254
	PostgreSQLParserMINVALUE                                              = 255
	PostgreSQLParserMODE                                                  = 256
	PostgreSQLParserMONTH_P                                               = 257
	PostgreSQLParserMOVE                                                  = 258
	PostgreSQLParserNAME_P                                                = 259
	PostgreSQLParserNAMES                                                 = 260
	PostgreSQLParserNEXT                                                  = 261
	PostgreSQLParserNO                                                    = 262
	PostgreSQLParserNOTHING                                               = 263
	PostgreSQLParserNOTIFY                                                = 264
	PostgreSQLParserNOWAIT                                                = 265
	PostgreSQLParserNULLS_P                                               = 266
	PostgreSQLParserOBJECT_P                                              = 267
	PostgreSQLParserOF                                                    = 268
	PostgreSQLParserOFF                                                   = 269
	PostgreSQLParserOIDS                                                  = 270
	PostgreSQLParserOPERATOR                                              = 271
	PostgreSQLParserOPTION                                                = 272
	PostgreSQLParserOPTIONS                                               = 273
	PostgreSQLParserOWNED                                                 = 274
	PostgreSQLParserOWNER                                                 = 275
	PostgreSQLParserPARSER                                                = 276
	PostgreSQLParserPARTIAL                                               = 277
	PostgreSQLParserPARTITION                                             = 278
	PostgreSQLParserPASSING                                               = 279
	PostgreSQLParserPASSWORD                                              = 280
	PostgreSQLParserPLANS                                                 = 281
	PostgreSQLParserPRECEDING                                             = 282
	PostgreSQLParserPREPARE                                               = 283
	PostgreSQLParserPREPARED                                              = 284
	PostgreSQLParserPRESERVE                                              = 285
	PostgreSQLParserPRIOR                                                 = 286
	PostgreSQLParserPRIVILEGES                                            = 287
	PostgreSQLParserPROCEDURAL                                            = 288
	PostgreSQLParserPROCEDURE                                             = 289
	PostgreSQLParserPROGRAM                                               = 290
	PostgreSQLParserQUOTE                                                 = 291
	PostgreSQLParserRANGE                                                 = 292
	PostgreSQLParserREAD                                                  = 293
	PostgreSQLParserREASSIGN                                              = 294
	PostgreSQLParserRECHECK                                               = 295
	PostgreSQLParserRECURSIVE                                             = 296
	PostgreSQLParserREF                                                   = 297
	PostgreSQLParserREFRESH                                               = 298
	PostgreSQLParserREINDEX                                               = 299
	PostgreSQLParserRELATIVE_P                                            = 300
	PostgreSQLParserRELEASE                                               = 301
	PostgreSQLParserRENAME                                                = 302
	PostgreSQLParserREPEATABLE                                            = 303
	PostgreSQLParserREPLACE                                               = 304
	PostgreSQLParserREPLICA                                               = 305
	PostgreSQLParserRESET                                                 = 306
	PostgreSQLParserRESTART                                               = 307
	PostgreSQLParserRESTRICT                                              = 308
	PostgreSQLParserRETURNS                                               = 309
	PostgreSQLParserREVOKE                                                = 310
	PostgreSQLParserROLE                                                  = 311
	PostgreSQLParserROLLBACK                                              = 312
	PostgreSQLParserROWS                                                  = 313
	PostgreSQLParserRULE                                                  = 314
	PostgreSQLParserSAVEPOINT                                             = 315
	PostgreSQLParserSCHEMA                                                = 316
	PostgreSQLParserSCROLL                                                = 317
	PostgreSQLParserSEARCH                                                = 318
	PostgreSQLParserSECOND_P                                              = 319
	PostgreSQLParserSECURITY                                              = 320
	PostgreSQLParserSEQUENCE                                              = 321
	PostgreSQLParserSEQUENCES                                             = 322
	PostgreSQLParserSERIALIZABLE                                          = 323
	PostgreSQLParserSERVER                                                = 324
	PostgreSQLParserSESSION                                               = 325
	PostgreSQLParserSET                                                   = 326
	PostgreSQLParserSHARE                                                 = 327
	PostgreSQLParserSHOW                                                  = 328
	PostgreSQLParserSIMPLE                                                = 329
	PostgreSQLParserSNAPSHOT                                              = 330
	PostgreSQLParserSTABLE                                                = 331
	PostgreSQLParserSTANDALONE_P                                          = 332
	PostgreSQLParserSTART                                                 = 333
	PostgreSQLParserSTATEMENT                                             = 334
	PostgreSQLParserSTATISTICS                                            = 335
	PostgreSQLParserSTDIN                                                 = 336
	PostgreSQLParserSTDOUT                                                = 337
	PostgreSQLParserSTORAGE                                               = 338
	PostgreSQLParserSTRICT_P                                              = 339
	PostgreSQLParserSTRIP_P                                               = 340
	PostgreSQLParserSYSID                                                 = 341
	PostgreSQLParserSYSTEM_P                                              = 342
	PostgreSQLParserTABLES                                                = 343
	PostgreSQLParserTABLESPACE                                            = 344
	PostgreSQLParserTEMP                                                  = 345
	PostgreSQLParserTEMPLATE                                              = 346
	PostgreSQLParserTEMPORARY                                             = 347
	PostgreSQLParserTEXT_P                                                = 348
	PostgreSQLParserTRANSACTION                                           = 349
	PostgreSQLParserTRIGGER                                               = 350
	PostgreSQLParserTRUNCATE                                              = 351
	PostgreSQLParserTRUSTED                                               = 352
	PostgreSQLParserTYPE_P                                                = 353
	PostgreSQLParserTYPES_P                                               = 354
	PostgreSQLParserUNBOUNDED                                             = 355
	PostgreSQLParserUNCOMMITTED                                           = 356
	PostgreSQLParserUNENCRYPTED                                           = 357
	PostgreSQLParserUNKNOWN                                               = 358
	PostgreSQLParserUNLISTEN                                              = 359
	PostgreSQLParserUNLOGGED                                              = 360
	PostgreSQLParserUNTIL                                                 = 361
	PostgreSQLParserUPDATE                                                = 362
	PostgreSQLParserVACUUM                                                = 363
	PostgreSQLParserVALID                                                 = 364
	PostgreSQLParserVALIDATE                                              = 365
	PostgreSQLParserVALIDATOR                                             = 366
	PostgreSQLParserVARYING                                               = 367
	PostgreSQLParserVERSION_P                                             = 368
	PostgreSQLParserVIEW                                                  = 369
	PostgreSQLParserVOLATILE                                              = 370
	PostgreSQLParserWHITESPACE_P                                          = 371
	PostgreSQLParserWITHOUT                                               = 372
	PostgreSQLParserWORK                                                  = 373
	PostgreSQLParserWRAPPER                                               = 374
	PostgreSQLParserWRITE                                                 = 375
	PostgreSQLParserXML_P                                                 = 376
	PostgreSQLParserYEAR_P                                                = 377
	PostgreSQLParserYES_P                                                 = 378
	PostgreSQLParserZONE                                                  = 379
	PostgreSQLParserBETWEEN                                               = 380
	PostgreSQLParserBIGINT                                                = 381
	PostgreSQLParserBIT                                                   = 382
	PostgreSQLParserBOOLEAN_P                                             = 383
	PostgreSQLParserCHAR_P                                                = 384
	PostgreSQLParserCHARACTER                                             = 385
	PostgreSQLParserCOALESCE                                              = 386
	PostgreSQLParserDEC                                                   = 387
	PostgreSQLParserDECIMAL_P                                             = 388
	PostgreSQLParserEXISTS                                                = 389
	PostgreSQLParserEXTRACT                                               = 390
	PostgreSQLParserFLOAT_P                                               = 391
	PostgreSQLParserGREATEST                                              = 392
	PostgreSQLParserINOUT                                                 = 393
	PostgreSQLParserINT_P                                                 = 394
	PostgreSQLParserINTEGER                                               = 395
	PostgreSQLParserINTERVAL                                              = 396
	PostgreSQLParserLEAST                                                 = 397
	PostgreSQLParserNATIONAL                                              = 398
	PostgreSQLParserNCHAR                                                 = 399
	PostgreSQLParserNONE                                                  = 400
	PostgreSQLParserNULLIF                                                = 401
	PostgreSQLParserNUMERIC                                               = 402
	PostgreSQLParserOVERLAY                                               = 403
	PostgreSQLParserPOSITION                                              = 404
	PostgreSQLParserPRECISION                                             = 405
	PostgreSQLParserREAL                                                  = 406
	PostgreSQLParserROW                                                   = 407
	PostgreSQLParserSETOF                                                 = 408
	PostgreSQLParserSMALLINT                                              = 409
	PostgreSQLParserSUBSTRING                                             = 410
	PostgreSQLParserTIME                                                  = 411
	PostgreSQLParserTIMESTAMP                                             = 412
	PostgreSQLParserTREAT                                                 = 413
	PostgreSQLParserTRIM                                                  = 414
	PostgreSQLParserVALUES                                                = 415
	PostgreSQLParserVARCHAR                                               = 416
	PostgreSQLParserXMLATTRIBUTES                                         = 417
	PostgreSQLParserXMLCOMMENT                                            = 418
	PostgreSQLParserXMLAGG                                                = 419
	PostgreSQLParserXML_IS_WELL_FORMED                                    = 420
	PostgreSQLParserXML_IS_WELL_FORMED_DOCUMENT                           = 421
	PostgreSQLParserXML_IS_WELL_FORMED_CONTENT                            = 422
	PostgreSQLParserXPATH                                                 = 423
	PostgreSQLParserXPATH_EXISTS                                          = 424
	PostgreSQLParserXMLCONCAT                                             = 425
	PostgreSQLParserXMLELEMENT                                            = 426
	PostgreSQLParserXMLEXISTS                                             = 427
	PostgreSQLParserXMLFOREST                                             = 428
	PostgreSQLParserXMLPARSE                                              = 429
	PostgreSQLParserXMLPI                                                 = 430
	PostgreSQLParserXMLROOT                                               = 431
	PostgreSQLParserXMLSERIALIZE                                          = 432
	PostgreSQLParserCALL                                                  = 433
	PostgreSQLParserCURRENT_P                                             = 434
	PostgreSQLParserATTACH                                                = 435
	PostgreSQLParserDETACH                                                = 436
	PostgreSQLParserEXPRESSION                                            = 437
	PostgreSQLParserGENERATED                                             = 438
	PostgreSQLParserLOGGED                                                = 439
	PostgreSQLParserSTORED                                                = 440
	PostgreSQLParserINCLUDE                                               = 441
	PostgreSQLParserROUTINE                                               = 442
	PostgreSQLParserTRANSFORM                                             = 443
	PostgreSQLParserIMPORT_P                                              = 444
	PostgreSQLParserPOLICY                                                = 445
	PostgreSQLParserMETHOD                                                = 446
	PostgreSQLParserREFERENCING                                           = 447
	PostgreSQLParserNEW                                                   = 448
	PostgreSQLParserOLD                                                   = 449
	PostgreSQLParserVALUE_P                                               = 450
	PostgreSQLParserSUBSCRIPTION                                          = 451
	PostgreSQLParserPUBLICATION                                           = 452
	PostgreSQLParserOUT_P                                                 = 453
	PostgreSQLParserEND_P                                                 = 454
	PostgreSQLParserROUTINES                                              = 455
	PostgreSQLParserSCHEMAS                                               = 456
	PostgreSQLParserPROCEDURES                                            = 457
	PostgreSQLParserINPUT_P                                               = 458
	PostgreSQLParserSUPPORT                                               = 459
	PostgreSQLParserPARALLEL                                              = 460
	PostgreSQLParserSQL_P                                                 = 461
	PostgreSQLParserDEPENDS                                               = 462
	PostgreSQLParserOVERRIDING                                            = 463
	PostgreSQLParserCONFLICT                                              = 464
	PostgreSQLParserSKIP_P                                                = 465
	PostgreSQLParserLOCKED                                                = 466
	PostgreSQLParserTIES                                                  = 467
	PostgreSQLParserROLLUP                                                = 468
	PostgreSQLParserCUBE                                                  = 469
	PostgreSQLParserGROUPING                                              = 470
	PostgreSQLParserSETS                                                  = 471
	PostgreSQLParserTABLESAMPLE                                           = 472
	PostgreSQLParserORDINALITY                                            = 473
	PostgreSQLParserXMLTABLE                                              = 474
	PostgreSQLParserCOLUMNS                                               = 475
	PostgreSQLParserXMLNAMESPACES                                         = 476
	PostgreSQLParserROWTYPE                                               = 477
	PostgreSQLParserNORMALIZED                                            = 478
	PostgreSQLParserWITHIN                                                = 479
	PostgreSQLParserFILTER                                                = 480
	PostgreSQLParserGROUPS                                                = 481
	PostgreSQLParserOTHERS                                                = 482
	PostgreSQLParserNFC                                                   = 483
	PostgreSQLParserNFD                                                   = 484
	PostgreSQLParserNFKC                                                  = 485
	PostgreSQLParserNFKD                                                  = 486
	PostgreSQLParserUESCAPE                                               = 487
	PostgreSQLParserVIEWS                                                 = 488
	PostgreSQLParserNORMALIZE                                             = 489
	PostgreSQLParserDUMP                                                  = 490
	PostgreSQLParserPRINT_STRICT_PARAMS                                   = 491
	PostgreSQLParserVARIABLE_CONFLICT                                     = 492
	PostgreSQLParserERROR                                                 = 493
	PostgreSQLParserUSE_VARIABLE                                          = 494
	PostgreSQLParserUSE_COLUMN                                            = 495
	PostgreSQLParserALIAS                                                 = 496
	PostgreSQLParserCONSTANT                                              = 497
	PostgreSQLParserPERFORM                                               = 498
	PostgreSQLParserGET                                                   = 499
	PostgreSQLParserDIAGNOSTICS                                           = 500
	PostgreSQLParserSTACKED                                               = 501
	PostgreSQLParserELSIF                                                 = 502
	PostgreSQLParserWHILE                                                 = 503
	PostgreSQLParserREVERSE                                               = 504
	PostgreSQLParserFOREACH                                               = 505
	PostgreSQLParserSLICE                                                 = 506
	PostgreSQLParserEXIT                                                  = 507
	PostgreSQLParserRETURN                                                = 508
	PostgreSQLParserQUERY                                                 = 509
	PostgreSQLParserRAISE                                                 = 510
	PostgreSQLParserSQLSTATE                                              = 511
	PostgreSQLParserDEBUG                                                 = 512
	PostgreSQLParserLOG                                                   = 513
	PostgreSQLParserINFO                                                  = 514
	PostgreSQLParserNOTICE                                                = 515
	PostgreSQLParserWARNING                                               = 516
	PostgreSQLParserEXCEPTION                                             = 517
	PostgreSQLParserASSERT                                                = 518
	PostgreSQLParserLOOP                                                  = 519
	PostgreSQLParserOPEN                                                  = 520
	PostgreSQLParserABS                                                   = 521
	PostgreSQLParserCBRT                                                  = 522
	PostgreSQLParserCEIL                                                  = 523
	PostgreSQLParserCEILING                                               = 524
	PostgreSQLParserDEGREES                                               = 525
	PostgreSQLParserDIV                                                   = 526
	PostgreSQLParserEXP                                                   = 527
	PostgreSQLParserFACTORIAL                                             = 528
	PostgreSQLParserFLOOR                                                 = 529
	PostgreSQLParserGCD                                                   = 530
	PostgreSQLParserLCM                                                   = 531
	PostgreSQLParserLN                                                    = 532
	PostgreSQLParserLOG10                                                 = 533
	PostgreSQLParserMIN_SCALE                                             = 534
	PostgreSQLParserMOD                                                   = 535
	PostgreSQLParserPI                                                    = 536
	PostgreSQLParserPOWER                                                 = 537
	PostgreSQLParserRADIANS                                               = 538
	PostgreSQLParserROUND                                                 = 539
	PostgreSQLParserSCALE                                                 = 540
	PostgreSQLParserSIGN                                                  = 541
	PostgreSQLParserSQRT                                                  = 542
	PostgreSQLParserTRIM_SCALE                                            = 543
	PostgreSQLParserTRUNC                                                 = 544
	PostgreSQLParserWIDTH_BUCKET                                          = 545
	PostgreSQLParserRANDOM                                                = 546
	PostgreSQLParserSETSEED                                               = 547
	PostgreSQLParserACOS                                                  = 548
	PostgreSQLParserACOSD                                                 = 549
	PostgreSQLParserASIN                                                  = 550
	PostgreSQLParserASIND                                                 = 551
	PostgreSQLParserATAN                                                  = 552
	PostgreSQLParserATAND                                                 = 553
	PostgreSQLParserATAN2                                                 = 554
	PostgreSQLParserATAN2D                                                = 555
	PostgreSQLParserCOS                                                   = 556
	PostgreSQLParserCOSD                                                  = 557
	PostgreSQLParserCOT                                                   = 558
	PostgreSQLParserCOTD                                                  = 559
	PostgreSQLParserSIN                                                   = 560
	PostgreSQLParserSIND                                                  = 561
	PostgreSQLParserTAN                                                   = 562
	PostgreSQLParserTAND                                                  = 563
	PostgreSQLParserSINH                                                  = 564
	PostgreSQLParserCOSH                                                  = 565
	PostgreSQLParserTANH                                                  = 566
	PostgreSQLParserASINH                                                 = 567
	PostgreSQLParserACOSH                                                 = 568
	PostgreSQLParserATANH                                                 = 569
	PostgreSQLParserBIT_LENGTH                                            = 570
	PostgreSQLParserCHAR_LENGTH                                           = 571
	PostgreSQLParserCHARACTER_LENGTH                                      = 572
	PostgreSQLParserLOWER                                                 = 573
	PostgreSQLParserOCTET_LENGTH                                          = 574
	PostgreSQLParserUPPER                                                 = 575
	PostgreSQLParserASCII                                                 = 576
	PostgreSQLParserBTRIM                                                 = 577
	PostgreSQLParserCHR                                                   = 578
	PostgreSQLParserCONCAT                                                = 579
	PostgreSQLParserCONCAT_WS                                             = 580
	PostgreSQLParserFORMAT                                                = 581
	PostgreSQLParserINITCAP                                               = 582
	PostgreSQLParserLENGTH                                                = 583
	PostgreSQLParserLPAD                                                  = 584
	PostgreSQLParserLTRIM                                                 = 585
	PostgreSQLParserMD5                                                   = 586
	PostgreSQLParserPARSE_IDENT                                           = 587
	PostgreSQLParserPG_CLIENT_ENCODING                                    = 588
	PostgreSQLParserQUOTE_IDENT                                           = 589
	PostgreSQLParserQUOTE_LITERAL                                         = 590
	PostgreSQLParserQUOTE_NULLABLE                                        = 591
	PostgreSQLParserREGEXP_COUNT                                          = 592
	PostgreSQLParserREGEXP_INSTR                                          = 593
	PostgreSQLParserREGEXP_LIKE                                           = 594
	PostgreSQLParserREGEXP_MATCH                                          = 595
	PostgreSQLParserREGEXP_MATCHES                                        = 596
	PostgreSQLParserREGEXP_REPLACE                                        = 597
	PostgreSQLParserREGEXP_SPLIT_TO_ARRAY                                 = 598
	PostgreSQLParserREGEXP_SPLIT_TO_TABLE                                 = 599
	PostgreSQLParserREGEXP_SUBSTR                                         = 600
	PostgreSQLParserREPEAT                                                = 601
	PostgreSQLParserRPAD                                                  = 602
	PostgreSQLParserRTRIM                                                 = 603
	PostgreSQLParserSPLIT_PART                                            = 604
	PostgreSQLParserSTARTS_WITH                                           = 605
	PostgreSQLParserSTRING_TO_ARRAY                                       = 606
	PostgreSQLParserSTRING_TO_TABLE                                       = 607
	PostgreSQLParserSTRPOS                                                = 608
	PostgreSQLParserSUBSTR                                                = 609
	PostgreSQLParserTO_ASCII                                              = 610
	PostgreSQLParserTO_HEX                                                = 611
	PostgreSQLParserTRANSLATE                                             = 612
	PostgreSQLParserUNISTR                                                = 613
	PostgreSQLParserAGE                                                   = 614
	PostgreSQLParserCLOCK_TIMESTAMP                                       = 615
	PostgreSQLParserDATE_BIN                                              = 616
	PostgreSQLParserDATE_PART                                             = 617
	PostgreSQLParserDATE_TRUNC                                            = 618
	PostgreSQLParserISFINITE                                              = 619
	PostgreSQLParserJUSTIFY_DAYS                                          = 620
	PostgreSQLParserJUSTIFY_HOURS                                         = 621
	PostgreSQLParserJUSTIFY_INTERVAL                                      = 622
	PostgreSQLParserMAKE_DATE                                             = 623
	PostgreSQLParserMAKE_INTERVAL                                         = 624
	PostgreSQLParserMAKE_TIME                                             = 625
	PostgreSQLParserMAKE_TIMESTAMP                                        = 626
	PostgreSQLParserMAKE_TIMESTAMPTZ                                      = 627
	PostgreSQLParserNOW                                                   = 628
	PostgreSQLParserSTATEMENT_TIMESTAMP                                   = 629
	PostgreSQLParserTIMEOFDAY                                             = 630
	PostgreSQLParserTRANSACTION_TIMESTAMP                                 = 631
	PostgreSQLParserTO_TIMESTAMP                                          = 632
	PostgreSQLParserTO_CHAR                                               = 633
	PostgreSQLParserTO_DATE                                               = 634
	PostgreSQLParserTO_NUMBER                                             = 635
	PostgreSQLParserIdentifier                                            = 636
	PostgreSQLParserQuotedIdentifier                                      = 637
	PostgreSQLParserUnterminatedQuotedIdentifier                          = 638
	PostgreSQLParserInvalidQuotedIdentifier                               = 639
	PostgreSQLParserInvalidUnterminatedQuotedIdentifier                   = 640
	PostgreSQLParserUnicodeQuotedIdentifier                               = 641
	PostgreSQLParserUnterminatedUnicodeQuotedIdentifier                   = 642
	PostgreSQLParserInvalidUnicodeQuotedIdentifier                        = 643
	PostgreSQLParserInvalidUnterminatedUnicodeQuotedIdentifier            = 644
	PostgreSQLParserStringConstant                                        = 645
	PostgreSQLParserUnterminatedStringConstant                            = 646
	PostgreSQLParserUnicodeEscapeStringConstant                           = 647
	PostgreSQLParserUnterminatedUnicodeEscapeStringConstant               = 648
	PostgreSQLParserBeginDollarStringConstant                             = 649
	PostgreSQLParserBinaryStringConstant                                  = 650
	PostgreSQLParserUnterminatedBinaryStringConstant                      = 651
	PostgreSQLParserInvalidBinaryStringConstant                           = 652
	PostgreSQLParserInvalidUnterminatedBinaryStringConstant               = 653
	PostgreSQLParserHexadecimalStringConstant                             = 654
	PostgreSQLParserUnterminatedHexadecimalStringConstant                 = 655
	PostgreSQLParserInvalidHexadecimalStringConstant                      = 656
	PostgreSQLParserInvalidUnterminatedHexadecimalStringConstant          = 657
	PostgreSQLParserIntegral                                              = 658
	PostgreSQLParserNumericFail                                           = 659
	PostgreSQLParserNumeric                                               = 660
	PostgreSQLParserPLSQLVARIABLENAME                                     = 661
	PostgreSQLParserPLSQLIDENTIFIER                                       = 662
	PostgreSQLParserWhitespace                                            = 663
	PostgreSQLParserNewline                                               = 664
	PostgreSQLParserLineComment                                           = 665
	PostgreSQLParserBlockComment                                          = 666
	PostgreSQLParserUnterminatedBlockComment                              = 667
	PostgreSQLParserMetaCommand                                           = 668
	PostgreSQLParserEndMetaCommand                                        = 669
	PostgreSQLParserErrorCharacter                                        = 670
	PostgreSQLParserEscapeStringConstant                                  = 671
	PostgreSQLParserUnterminatedEscapeStringConstant                      = 672
	PostgreSQLParserInvalidEscapeStringConstant                           = 673
	PostgreSQLParserInvalidUnterminatedEscapeStringConstant               = 674
	PostgreSQLParserAfterEscapeStringConstantMode_NotContinued            = 675
	PostgreSQLParserAfterEscapeStringConstantWithNewlineMode_NotContinued = 676
	PostgreSQLParserDollarText                                            = 677
	PostgreSQLParserEndDollarStringConstant                               = 678
	PostgreSQLParserAfterEscapeStringConstantWithNewlineMode_Continued    = 679
)

// PostgreSQLParser rules.
const (
	PostgreSQLParserRULE_root                              = 0
	PostgreSQLParserRULE_plsqlroot                         = 1
	PostgreSQLParserRULE_stmtblock                         = 2
	PostgreSQLParserRULE_stmtmulti                         = 3
	PostgreSQLParserRULE_stmt                              = 4
	PostgreSQLParserRULE_plsqlconsolecommand               = 5
	PostgreSQLParserRULE_callstmt                          = 6
	PostgreSQLParserRULE_createrolestmt                    = 7
	PostgreSQLParserRULE_opt_with                          = 8
	PostgreSQLParserRULE_optrolelist                       = 9
	PostgreSQLParserRULE_alteroptrolelist                  = 10
	PostgreSQLParserRULE_alteroptroleelem                  = 11
	PostgreSQLParserRULE_createoptroleelem                 = 12
	PostgreSQLParserRULE_createuserstmt                    = 13
	PostgreSQLParserRULE_alterrolestmt                     = 14
	PostgreSQLParserRULE_opt_in_database                   = 15
	PostgreSQLParserRULE_alterrolesetstmt                  = 16
	PostgreSQLParserRULE_droprolestmt                      = 17
	PostgreSQLParserRULE_creategroupstmt                   = 18
	PostgreSQLParserRULE_altergroupstmt                    = 19
	PostgreSQLParserRULE_add_drop                          = 20
	PostgreSQLParserRULE_createschemastmt                  = 21
	PostgreSQLParserRULE_optschemaname                     = 22
	PostgreSQLParserRULE_optschemaeltlist                  = 23
	PostgreSQLParserRULE_schema_stmt                       = 24
	PostgreSQLParserRULE_variablesetstmt                   = 25
	PostgreSQLParserRULE_set_rest                          = 26
	PostgreSQLParserRULE_generic_set                       = 27
	PostgreSQLParserRULE_set_rest_more                     = 28
	PostgreSQLParserRULE_var_name                          = 29
	PostgreSQLParserRULE_var_list                          = 30
	PostgreSQLParserRULE_var_value                         = 31
	PostgreSQLParserRULE_iso_level                         = 32
	PostgreSQLParserRULE_opt_boolean_or_string             = 33
	PostgreSQLParserRULE_zone_value                        = 34
	PostgreSQLParserRULE_opt_encoding                      = 35
	PostgreSQLParserRULE_nonreservedword_or_sconst         = 36
	PostgreSQLParserRULE_variableresetstmt                 = 37
	PostgreSQLParserRULE_reset_rest                        = 38
	PostgreSQLParserRULE_generic_reset                     = 39
	PostgreSQLParserRULE_setresetclause                    = 40
	PostgreSQLParserRULE_functionsetresetclause            = 41
	PostgreSQLParserRULE_variableshowstmt                  = 42
	PostgreSQLParserRULE_constraintssetstmt                = 43
	PostgreSQLParserRULE_constraints_set_list              = 44
	PostgreSQLParserRULE_constraints_set_mode              = 45
	PostgreSQLParserRULE_checkpointstmt                    = 46
	PostgreSQLParserRULE_discardstmt                       = 47
	PostgreSQLParserRULE_altertablestmt                    = 48
	PostgreSQLParserRULE_alter_table_cmds                  = 49
	PostgreSQLParserRULE_partition_cmd                     = 50
	PostgreSQLParserRULE_index_partition_cmd               = 51
	PostgreSQLParserRULE_alter_table_cmd                   = 52
	PostgreSQLParserRULE_alter_column_default              = 53
	PostgreSQLParserRULE_opt_drop_behavior                 = 54
	PostgreSQLParserRULE_opt_collate_clause                = 55
	PostgreSQLParserRULE_alter_using                       = 56
	PostgreSQLParserRULE_replica_identity                  = 57
	PostgreSQLParserRULE_reloptions                        = 58
	PostgreSQLParserRULE_opt_reloptions                    = 59
	PostgreSQLParserRULE_reloption_list                    = 60
	PostgreSQLParserRULE_reloption_elem                    = 61
	PostgreSQLParserRULE_alter_identity_column_option_list = 62
	PostgreSQLParserRULE_alter_identity_column_option      = 63
	PostgreSQLParserRULE_partitionboundspec                = 64
	PostgreSQLParserRULE_hash_partbound_elem               = 65
	PostgreSQLParserRULE_hash_partbound                    = 66
	PostgreSQLParserRULE_altercompositetypestmt            = 67
	PostgreSQLParserRULE_alter_type_cmds                   = 68
	PostgreSQLParserRULE_alter_type_cmd                    = 69
	PostgreSQLParserRULE_closeportalstmt                   = 70
	PostgreSQLParserRULE_copystmt                          = 71
	PostgreSQLParserRULE_copy_from                         = 72
	PostgreSQLParserRULE_opt_program                       = 73
	PostgreSQLParserRULE_copy_file_name                    = 74
	PostgreSQLParserRULE_copy_options                      = 75
	PostgreSQLParserRULE_copy_opt_list                     = 76
	PostgreSQLParserRULE_copy_opt_item                     = 77
	PostgreSQLParserRULE_opt_binary                        = 78
	PostgreSQLParserRULE_copy_delimiter                    = 79
	PostgreSQLParserRULE_opt_using                         = 80
	PostgreSQLParserRULE_copy_generic_opt_list             = 81
	PostgreSQLParserRULE_copy_generic_opt_elem             = 82
	PostgreSQLParserRULE_copy_generic_opt_arg              = 83
	PostgreSQLParserRULE_copy_generic_opt_arg_list         = 84
	PostgreSQLParserRULE_copy_generic_opt_arg_list_item    = 85
	PostgreSQLParserRULE_createstmt                        = 86
	PostgreSQLParserRULE_opttemp                           = 87
	PostgreSQLParserRULE_opttableelementlist               = 88
	PostgreSQLParserRULE_opttypedtableelementlist          = 89
	PostgreSQLParserRULE_tableelementlist                  = 90
	PostgreSQLParserRULE_typedtableelementlist             = 91
	PostgreSQLParserRULE_tableelement                      = 92
	PostgreSQLParserRULE_typedtableelement                 = 93
	PostgreSQLParserRULE_columnDef                         = 94
	PostgreSQLParserRULE_columnOptions                     = 95
	PostgreSQLParserRULE_colquallist                       = 96
	PostgreSQLParserRULE_colconstraint                     = 97
	PostgreSQLParserRULE_colconstraintelem                 = 98
	PostgreSQLParserRULE_generated_when                    = 99
	PostgreSQLParserRULE_constraintattr                    = 100
	PostgreSQLParserRULE_tablelikeclause                   = 101
	PostgreSQLParserRULE_tablelikeoptionlist               = 102
	PostgreSQLParserRULE_tablelikeoption                   = 103
	PostgreSQLParserRULE_tableconstraint                   = 104
	PostgreSQLParserRULE_constraintelem                    = 105
	PostgreSQLParserRULE_opt_no_inherit                    = 106
	PostgreSQLParserRULE_opt_column_list                   = 107
	PostgreSQLParserRULE_columnlist                        = 108
	PostgreSQLParserRULE_columnElem                        = 109
	PostgreSQLParserRULE_opt_c_include                     = 110
	PostgreSQLParserRULE_key_match                         = 111
	PostgreSQLParserRULE_exclusionconstraintlist           = 112
	PostgreSQLParserRULE_exclusionconstraintelem           = 113
	PostgreSQLParserRULE_exclusionwhereclause              = 114
	PostgreSQLParserRULE_key_actions                       = 115
	PostgreSQLParserRULE_key_update                        = 116
	PostgreSQLParserRULE_key_delete                        = 117
	PostgreSQLParserRULE_key_action                        = 118
	PostgreSQLParserRULE_optinherit                        = 119
	PostgreSQLParserRULE_optpartitionspec                  = 120
	PostgreSQLParserRULE_partitionspec                     = 121
	PostgreSQLParserRULE_part_params                       = 122
	PostgreSQLParserRULE_part_elem                         = 123
	PostgreSQLParserRULE_table_access_method_clause        = 124
	PostgreSQLParserRULE_optwith                           = 125
	PostgreSQLParserRULE_oncommitoption                    = 126
	PostgreSQLParserRULE_opttablespace                     = 127
	PostgreSQLParserRULE_optconstablespace                 = 128
	PostgreSQLParserRULE_existingindex                     = 129
	PostgreSQLParserRULE_createstatsstmt                   = 130
	PostgreSQLParserRULE_alterstatsstmt                    = 131
	PostgreSQLParserRULE_createasstmt                      = 132
	PostgreSQLParserRULE_create_as_target                  = 133
	PostgreSQLParserRULE_opt_with_data                     = 134
	PostgreSQLParserRULE_creatematviewstmt                 = 135
	PostgreSQLParserRULE_create_mv_target                  = 136
	PostgreSQLParserRULE_optnolog                          = 137
	PostgreSQLParserRULE_refreshmatviewstmt                = 138
	PostgreSQLParserRULE_createseqstmt                     = 139
	PostgreSQLParserRULE_alterseqstmt                      = 140
	PostgreSQLParserRULE_optseqoptlist                     = 141
	PostgreSQLParserRULE_optparenthesizedseqoptlist        = 142
	PostgreSQLParserRULE_seqoptlist                        = 143
	PostgreSQLParserRULE_seqoptelem                        = 144
	PostgreSQLParserRULE_opt_by                            = 145
	PostgreSQLParserRULE_numericonly                       = 146
	PostgreSQLParserRULE_numericonly_list                  = 147
	PostgreSQLParserRULE_createplangstmt                   = 148
	PostgreSQLParserRULE_opt_trusted                       = 149
	PostgreSQLParserRULE_handler_name                      = 150
	PostgreSQLParserRULE_opt_inline_handler                = 151
	PostgreSQLParserRULE_validator_clause                  = 152
	PostgreSQLParserRULE_opt_validator                     = 153
	PostgreSQLParserRULE_opt_procedural                    = 154
	PostgreSQLParserRULE_createtablespacestmt              = 155
	PostgreSQLParserRULE_opttablespaceowner                = 156
	PostgreSQLParserRULE_droptablespacestmt                = 157
	PostgreSQLParserRULE_createextensionstmt               = 158
	PostgreSQLParserRULE_create_extension_opt_list         = 159
	PostgreSQLParserRULE_create_extension_opt_item         = 160
	PostgreSQLParserRULE_alterextensionstmt                = 161
	PostgreSQLParserRULE_alter_extension_opt_list          = 162
	PostgreSQLParserRULE_alter_extension_opt_item          = 163
	PostgreSQLParserRULE_alterextensioncontentsstmt        = 164
	PostgreSQLParserRULE_createfdwstmt                     = 165
	PostgreSQLParserRULE_fdw_option                        = 166
	PostgreSQLParserRULE_fdw_options                       = 167
	PostgreSQLParserRULE_opt_fdw_options                   = 168
	PostgreSQLParserRULE_alterfdwstmt                      = 169
	PostgreSQLParserRULE_create_generic_options            = 170
	PostgreSQLParserRULE_generic_option_list               = 171
	PostgreSQLParserRULE_alter_generic_options             = 172
	PostgreSQLParserRULE_alter_generic_option_list         = 173
	PostgreSQLParserRULE_alter_generic_option_elem         = 174
	PostgreSQLParserRULE_generic_option_elem               = 175
	PostgreSQLParserRULE_generic_option_name               = 176
	PostgreSQLParserRULE_generic_option_arg                = 177
	PostgreSQLParserRULE_createforeignserverstmt           = 178
	PostgreSQLParserRULE_opt_type                          = 179
	PostgreSQLParserRULE_foreign_server_version            = 180
	PostgreSQLParserRULE_opt_foreign_server_version        = 181
	PostgreSQLParserRULE_alterforeignserverstmt            = 182
	PostgreSQLParserRULE_createforeigntablestmt            = 183
	PostgreSQLParserRULE_importforeignschemastmt           = 184
	PostgreSQLParserRULE_import_qualification_type         = 185
	PostgreSQLParserRULE_import_qualification              = 186
	PostgreSQLParserRULE_createusermappingstmt             = 187
	PostgreSQLParserRULE_auth_ident                        = 188
	PostgreSQLParserRULE_dropusermappingstmt               = 189
	PostgreSQLParserRULE_alterusermappingstmt              = 190
	PostgreSQLParserRULE_createpolicystmt                  = 191
	PostgreSQLParserRULE_alterpolicystmt                   = 192
	PostgreSQLParserRULE_rowsecurityoptionalexpr           = 193
	PostgreSQLParserRULE_rowsecurityoptionalwithcheck      = 194
	PostgreSQLParserRULE_rowsecuritydefaulttorole          = 195
	PostgreSQLParserRULE_rowsecurityoptionaltorole         = 196
	PostgreSQLParserRULE_rowsecuritydefaultpermissive      = 197
	PostgreSQLParserRULE_rowsecuritydefaultforcmd          = 198
	PostgreSQLParserRULE_row_security_cmd                  = 199
	PostgreSQLParserRULE_createamstmt                      = 200
	PostgreSQLParserRULE_am_type                           = 201
	PostgreSQLParserRULE_createtrigstmt                    = 202
	PostgreSQLParserRULE_triggeractiontime                 = 203
	PostgreSQLParserRULE_triggerevents                     = 204
	PostgreSQLParserRULE_triggeroneevent                   = 205
	PostgreSQLParserRULE_triggerreferencing                = 206
	PostgreSQLParserRULE_triggertransitions                = 207
	PostgreSQLParserRULE_triggertransition                 = 208
	PostgreSQLParserRULE_transitionoldornew                = 209
	PostgreSQLParserRULE_transitionrowortable              = 210
	PostgreSQLParserRULE_transitionrelname                 = 211
	PostgreSQLParserRULE_triggerforspec                    = 212
	PostgreSQLParserRULE_triggerforopteach                 = 213
	PostgreSQLParserRULE_triggerfortype                    = 214
	PostgreSQLParserRULE_triggerwhen                       = 215
	PostgreSQLParserRULE_function_or_procedure             = 216
	PostgreSQLParserRULE_triggerfuncargs                   = 217
	PostgreSQLParserRULE_triggerfuncarg                    = 218
	PostgreSQLParserRULE_optconstrfromtable                = 219
	PostgreSQLParserRULE_constraintattributespec           = 220
	PostgreSQLParserRULE_constraintattributeElem           = 221
	PostgreSQLParserRULE_createeventtrigstmt               = 222
	PostgreSQLParserRULE_event_trigger_when_list           = 223
	PostgreSQLParserRULE_event_trigger_when_item           = 224
	PostgreSQLParserRULE_event_trigger_value_list          = 225
	PostgreSQLParserRULE_altereventtrigstmt                = 226
	PostgreSQLParserRULE_enable_trigger                    = 227
	PostgreSQLParserRULE_createassertionstmt               = 228
	PostgreSQLParserRULE_definestmt                        = 229
	PostgreSQLParserRULE_definition                        = 230
	PostgreSQLParserRULE_def_list                          = 231
	PostgreSQLParserRULE_def_elem                          = 232
	PostgreSQLParserRULE_def_arg                           = 233
	PostgreSQLParserRULE_old_aggr_definition               = 234
	PostgreSQLParserRULE_old_aggr_list                     = 235
	PostgreSQLParserRULE_old_aggr_elem                     = 236
	PostgreSQLParserRULE_opt_enum_val_list                 = 237
	PostgreSQLParserRULE_enum_val_list                     = 238
	PostgreSQLParserRULE_alterenumstmt                     = 239
	PostgreSQLParserRULE_opt_if_not_exists                 = 240
	PostgreSQLParserRULE_createopclassstmt                 = 241
	PostgreSQLParserRULE_opclass_item_list                 = 242
	PostgreSQLParserRULE_opclass_item                      = 243
	PostgreSQLParserRULE_opt_default                       = 244
	PostgreSQLParserRULE_opt_opfamily                      = 245
	PostgreSQLParserRULE_opclass_purpose                   = 246
	PostgreSQLParserRULE_opt_recheck                       = 247
	PostgreSQLParserRULE_createopfamilystmt                = 248
	PostgreSQLParserRULE_alteropfamilystmt                 = 249
	PostgreSQLParserRULE_opclass_drop_list                 = 250
	PostgreSQLParserRULE_opclass_drop                      = 251
	PostgreSQLParserRULE_dropopclassstmt                   = 252
	PostgreSQLParserRULE_dropopfamilystmt                  = 253
	PostgreSQLParserRULE_dropownedstmt                     = 254
	PostgreSQLParserRULE_reassignownedstmt                 = 255
	PostgreSQLParserRULE_dropstmt                          = 256
	PostgreSQLParserRULE_object_type_any_name              = 257
	PostgreSQLParserRULE_object_type_name                  = 258
	PostgreSQLParserRULE_drop_type_name                    = 259
	PostgreSQLParserRULE_object_type_name_on_any_name      = 260
	PostgreSQLParserRULE_any_name_list                     = 261
	PostgreSQLParserRULE_any_name                          = 262
	PostgreSQLParserRULE_attrs                             = 263
	PostgreSQLParserRULE_type_name_list                    = 264
	PostgreSQLParserRULE_truncatestmt                      = 265
	PostgreSQLParserRULE_opt_restart_seqs                  = 266
	PostgreSQLParserRULE_commentstmt                       = 267
	PostgreSQLParserRULE_comment_text                      = 268
	PostgreSQLParserRULE_seclabelstmt                      = 269
	PostgreSQLParserRULE_opt_provider                      = 270
	PostgreSQLParserRULE_security_label                    = 271
	PostgreSQLParserRULE_fetchstmt                         = 272
	PostgreSQLParserRULE_fetch_args                        = 273
	PostgreSQLParserRULE_from_in                           = 274
	PostgreSQLParserRULE_opt_from_in                       = 275
	PostgreSQLParserRULE_grantstmt                         = 276
	PostgreSQLParserRULE_revokestmt                        = 277
	PostgreSQLParserRULE_privileges                        = 278
	PostgreSQLParserRULE_privilege_list                    = 279
	PostgreSQLParserRULE_privilege                         = 280
	PostgreSQLParserRULE_privilege_target                  = 281
	PostgreSQLParserRULE_grantee_list                      = 282
	PostgreSQLParserRULE_grantee                           = 283
	PostgreSQLParserRULE_opt_grant_grant_option            = 284
	PostgreSQLParserRULE_grantrolestmt                     = 285
	PostgreSQLParserRULE_revokerolestmt                    = 286
	PostgreSQLParserRULE_opt_grant_admin_option            = 287
	PostgreSQLParserRULE_opt_granted_by                    = 288
	PostgreSQLParserRULE_alterdefaultprivilegesstmt        = 289
	PostgreSQLParserRULE_defacloptionlist                  = 290
	PostgreSQLParserRULE_defacloption                      = 291
	PostgreSQLParserRULE_defaclaction                      = 292
	PostgreSQLParserRULE_defacl_privilege_target           = 293
	PostgreSQLParserRULE_indexstmt                         = 294
	PostgreSQLParserRULE_opt_unique                        = 295
	PostgreSQLParserRULE_opt_concurrently                  = 296
	PostgreSQLParserRULE_opt_index_name                    = 297
	PostgreSQLParserRULE_access_method_clause              = 298
	PostgreSQLParserRULE_index_params                      = 299
	PostgreSQLParserRULE_index_elem_options                = 300
	PostgreSQLParserRULE_index_elem                        = 301
	PostgreSQLParserRULE_opt_include                       = 302
	PostgreSQLParserRULE_index_including_params            = 303
	PostgreSQLParserRULE_opt_collate                       = 304
	PostgreSQLParserRULE_opt_class                         = 305
	PostgreSQLParserRULE_opt_asc_desc                      = 306
	PostgreSQLParserRULE_opt_nulls_order                   = 307
	PostgreSQLParserRULE_createfunctionstmt                = 308
	PostgreSQLParserRULE_opt_or_replace                    = 309
	PostgreSQLParserRULE_func_args                         = 310
	PostgreSQLParserRULE_func_args_list                    = 311
	PostgreSQLParserRULE_function_with_argtypes_list       = 312
	PostgreSQLParserRULE_function_with_argtypes            = 313
	PostgreSQLParserRULE_func_args_with_defaults           = 314
	PostgreSQLParserRULE_func_args_with_defaults_list      = 315
	PostgreSQLParserRULE_func_arg                          = 316
	PostgreSQLParserRULE_arg_class                         = 317
	PostgreSQLParserRULE_param_name                        = 318
	PostgreSQLParserRULE_func_return                       = 319
	PostgreSQLParserRULE_func_type                         = 320
	PostgreSQLParserRULE_func_arg_with_default             = 321
	PostgreSQLParserRULE_aggr_arg                          = 322
	PostgreSQLParserRULE_aggr_args                         = 323
	PostgreSQLParserRULE_aggr_args_list                    = 324
	PostgreSQLParserRULE_aggregate_with_argtypes           = 325
	PostgreSQLParserRULE_aggregate_with_argtypes_list      = 326
	PostgreSQLParserRULE_createfunc_opt_list               = 327
	PostgreSQLParserRULE_common_func_opt_item              = 328
	PostgreSQLParserRULE_createfunc_opt_item               = 329
	PostgreSQLParserRULE_func_as                           = 330
	PostgreSQLParserRULE_transform_type_list               = 331
	PostgreSQLParserRULE_opt_definition                    = 332
	PostgreSQLParserRULE_table_func_column                 = 333
	PostgreSQLParserRULE_table_func_column_list            = 334
	PostgreSQLParserRULE_alterfunctionstmt                 = 335
	PostgreSQLParserRULE_alterfunc_opt_list                = 336
	PostgreSQLParserRULE_opt_restrict                      = 337
	PostgreSQLParserRULE_removefuncstmt                    = 338
	PostgreSQLParserRULE_removeaggrstmt                    = 339
	PostgreSQLParserRULE_removeoperstmt                    = 340
	PostgreSQLParserRULE_oper_argtypes                     = 341
	PostgreSQLParserRULE_any_operator                      = 342
	PostgreSQLParserRULE_operator_with_argtypes_list       = 343
	PostgreSQLParserRULE_operator_with_argtypes            = 344
	PostgreSQLParserRULE_dostmt                            = 345
	PostgreSQLParserRULE_dostmt_opt_list                   = 346
	PostgreSQLParserRULE_dostmt_opt_item                   = 347
	PostgreSQLParserRULE_createcaststmt                    = 348
	PostgreSQLParserRULE_cast_context                      = 349
	PostgreSQLParserRULE_dropcaststmt                      = 350
	PostgreSQLParserRULE_opt_if_exists                     = 351
	PostgreSQLParserRULE_createtransformstmt               = 352
	PostgreSQLParserRULE_transform_element_list            = 353
	PostgreSQLParserRULE_droptransformstmt                 = 354
	PostgreSQLParserRULE_reindexstmt                       = 355
	PostgreSQLParserRULE_reindex_target_type               = 356
	PostgreSQLParserRULE_reindex_target_multitable         = 357
	PostgreSQLParserRULE_reindex_option_list               = 358
	PostgreSQLParserRULE_reindex_option_elem               = 359
	PostgreSQLParserRULE_altertblspcstmt                   = 360
	PostgreSQLParserRULE_renamestmt                        = 361
	PostgreSQLParserRULE_opt_column                        = 362
	PostgreSQLParserRULE_opt_set_data                      = 363
	PostgreSQLParserRULE_alterobjectdependsstmt            = 364
	PostgreSQLParserRULE_opt_no                            = 365
	PostgreSQLParserRULE_alterobjectschemastmt             = 366
	PostgreSQLParserRULE_alteroperatorstmt                 = 367
	PostgreSQLParserRULE_operator_def_list                 = 368
	PostgreSQLParserRULE_operator_def_elem                 = 369
	PostgreSQLParserRULE_operator_def_arg                  = 370
	PostgreSQLParserRULE_altertypestmt                     = 371
	PostgreSQLParserRULE_alterownerstmt                    = 372
	PostgreSQLParserRULE_createpublicationstmt             = 373
	PostgreSQLParserRULE_opt_publication_for_tables        = 374
	PostgreSQLParserRULE_publication_for_tables            = 375
	PostgreSQLParserRULE_alterpublicationstmt              = 376
	PostgreSQLParserRULE_createsubscriptionstmt            = 377
	PostgreSQLParserRULE_publication_name_list             = 378
	PostgreSQLParserRULE_publication_name_item             = 379
	PostgreSQLParserRULE_altersubscriptionstmt             = 380
	PostgreSQLParserRULE_dropsubscriptionstmt              = 381
	PostgreSQLParserRULE_rulestmt                          = 382
	PostgreSQLParserRULE_ruleactionlist                    = 383
	PostgreSQLParserRULE_ruleactionmulti                   = 384
	PostgreSQLParserRULE_ruleactionstmt                    = 385
	PostgreSQLParserRULE_ruleactionstmtOrEmpty             = 386
	PostgreSQLParserRULE_event                             = 387
	PostgreSQLParserRULE_opt_instead                       = 388
	PostgreSQLParserRULE_notifystmt                        = 389
	PostgreSQLParserRULE_notify_payload                    = 390
	PostgreSQLParserRULE_listenstmt                        = 391
	PostgreSQLParserRULE_unlistenstmt                      = 392
	PostgreSQLParserRULE_transactionstmt                   = 393
	PostgreSQLParserRULE_opt_transaction                   = 394
	PostgreSQLParserRULE_transaction_mode_item             = 395
	PostgreSQLParserRULE_transaction_mode_list             = 396
	PostgreSQLParserRULE_transaction_mode_list_or_empty    = 397
	PostgreSQLParserRULE_opt_transaction_chain             = 398
	PostgreSQLParserRULE_viewstmt                          = 399
	PostgreSQLParserRULE_opt_check_option                  = 400
	PostgreSQLParserRULE_loadstmt                          = 401
	PostgreSQLParserRULE_createdbstmt                      = 402
	PostgreSQLParserRULE_createdb_opt_list                 = 403
	PostgreSQLParserRULE_createdb_opt_items                = 404
	PostgreSQLParserRULE_createdb_opt_item                 = 405
	PostgreSQLParserRULE_createdb_opt_name                 = 406
	PostgreSQLParserRULE_opt_equal                         = 407
	PostgreSQLParserRULE_alterdatabasestmt                 = 408
	PostgreSQLParserRULE_alterdatabasesetstmt              = 409
	PostgreSQLParserRULE_dropdbstmt                        = 410
	PostgreSQLParserRULE_drop_option_list                  = 411
	PostgreSQLParserRULE_drop_option                       = 412
	PostgreSQLParserRULE_altercollationstmt                = 413
	PostgreSQLParserRULE_altersystemstmt                   = 414
	PostgreSQLParserRULE_createdomainstmt                  = 415
	PostgreSQLParserRULE_alterdomainstmt                   = 416
	PostgreSQLParserRULE_opt_as                            = 417
	PostgreSQLParserRULE_altertsdictionarystmt             = 418
	PostgreSQLParserRULE_altertsconfigurationstmt          = 419
	PostgreSQLParserRULE_any_with                          = 420
	PostgreSQLParserRULE_createconversionstmt              = 421
	PostgreSQLParserRULE_clusterstmt                       = 422
	PostgreSQLParserRULE_cluster_index_specification       = 423
	PostgreSQLParserRULE_vacuumstmt                        = 424
	PostgreSQLParserRULE_analyzestmt                       = 425
	PostgreSQLParserRULE_vac_analyze_option_list           = 426
	PostgreSQLParserRULE_analyze_keyword                   = 427
	PostgreSQLParserRULE_vac_analyze_option_elem           = 428
	PostgreSQLParserRULE_vac_analyze_option_name           = 429
	PostgreSQLParserRULE_vac_analyze_option_arg            = 430
	PostgreSQLParserRULE_opt_analyze                       = 431
	PostgreSQLParserRULE_opt_verbose                       = 432
	PostgreSQLParserRULE_opt_full                          = 433
	PostgreSQLParserRULE_opt_freeze                        = 434
	PostgreSQLParserRULE_opt_name_list                     = 435
	PostgreSQLParserRULE_vacuum_relation                   = 436
	PostgreSQLParserRULE_vacuum_relation_list              = 437
	PostgreSQLParserRULE_opt_vacuum_relation_list          = 438
	PostgreSQLParserRULE_explainstmt                       = 439
	PostgreSQLParserRULE_explainablestmt                   = 440
	PostgreSQLParserRULE_explain_option_list               = 441
	PostgreSQLParserRULE_explain_option_elem               = 442
	PostgreSQLParserRULE_explain_option_name               = 443
	PostgreSQLParserRULE_explain_option_arg                = 444
	PostgreSQLParserRULE_preparestmt                       = 445
	PostgreSQLParserRULE_prep_type_clause                  = 446
	PostgreSQLParserRULE_preparablestmt                    = 447
	PostgreSQLParserRULE_executestmt                       = 448
	PostgreSQLParserRULE_execute_param_clause              = 449
	PostgreSQLParserRULE_deallocatestmt                    = 450
	PostgreSQLParserRULE_insertstmt                        = 451
	PostgreSQLParserRULE_insert_target                     = 452
	PostgreSQLParserRULE_insert_rest                       = 453
	PostgreSQLParserRULE_override_kind                     = 454
	PostgreSQLParserRULE_insert_column_list                = 455
	PostgreSQLParserRULE_insert_column_item                = 456
	PostgreSQLParserRULE_opt_on_conflict                   = 457
	PostgreSQLParserRULE_opt_conf_expr                     = 458
	PostgreSQLParserRULE_returning_clause                  = 459
	PostgreSQLParserRULE_mergestmt                         = 460
	PostgreSQLParserRULE_merge_insert_clause               = 461
	PostgreSQLParserRULE_merge_update_clause               = 462
	PostgreSQLParserRULE_merge_delete_clause               = 463
	PostgreSQLParserRULE_deletestmt                        = 464
	PostgreSQLParserRULE_using_clause                      = 465
	PostgreSQLParserRULE_lockstmt                          = 466
	PostgreSQLParserRULE_opt_lock                          = 467
	PostgreSQLParserRULE_lock_type                         = 468
	PostgreSQLParserRULE_opt_nowait                        = 469
	PostgreSQLParserRULE_opt_nowait_or_skip                = 470
	PostgreSQLParserRULE_updatestmt                        = 471
	PostgreSQLParserRULE_set_clause_list                   = 472
	PostgreSQLParserRULE_set_clause                        = 473
	PostgreSQLParserRULE_set_target                        = 474
	PostgreSQLParserRULE_set_target_list                   = 475
	PostgreSQLParserRULE_declarecursorstmt                 = 476
	PostgreSQLParserRULE_cursor_name                       = 477
	PostgreSQLParserRULE_cursor_options                    = 478
	PostgreSQLParserRULE_opt_hold                          = 479
	PostgreSQLParserRULE_selectstmt                        = 480
	PostgreSQLParserRULE_select_with_parens                = 481
	PostgreSQLParserRULE_select_no_parens                  = 482
	PostgreSQLParserRULE_select_clause                     = 483
	PostgreSQLParserRULE_simple_select_intersect           = 484
	PostgreSQLParserRULE_simple_select_pramary             = 485
	PostgreSQLParserRULE_with_clause                       = 486
	PostgreSQLParserRULE_cte_list                          = 487
	PostgreSQLParserRULE_common_table_expr                 = 488
	PostgreSQLParserRULE_opt_materialized                  = 489
	PostgreSQLParserRULE_opt_with_clause                   = 490
	PostgreSQLParserRULE_into_clause                       = 491
	PostgreSQLParserRULE_opt_strict                        = 492
	PostgreSQLParserRULE_opttempTableName                  = 493
	PostgreSQLParserRULE_opt_table                         = 494
	PostgreSQLParserRULE_all_or_distinct                   = 495
	PostgreSQLParserRULE_distinct_clause                   = 496
	PostgreSQLParserRULE_opt_all_clause                    = 497
	PostgreSQLParserRULE_opt_sort_clause                   = 498
	PostgreSQLParserRULE_sort_clause                       = 499
	PostgreSQLParserRULE_sortby_list                       = 500
	PostgreSQLParserRULE_sortby                            = 501
	PostgreSQLParserRULE_select_limit                      = 502
	PostgreSQLParserRULE_opt_select_limit                  = 503
	PostgreSQLParserRULE_limit_clause                      = 504
	PostgreSQLParserRULE_offset_clause                     = 505
	PostgreSQLParserRULE_select_limit_value                = 506
	PostgreSQLParserRULE_select_offset_value               = 507
	PostgreSQLParserRULE_select_fetch_first_value          = 508
	PostgreSQLParserRULE_i_or_f_const                      = 509
	PostgreSQLParserRULE_row_or_rows                       = 510
	PostgreSQLParserRULE_first_or_next                     = 511
	PostgreSQLParserRULE_group_clause                      = 512
	PostgreSQLParserRULE_group_by_list                     = 513
	PostgreSQLParserRULE_group_by_item                     = 514
	PostgreSQLParserRULE_empty_grouping_set                = 515
	PostgreSQLParserRULE_rollup_clause                     = 516
	PostgreSQLParserRULE_cube_clause                       = 517
	PostgreSQLParserRULE_grouping_sets_clause              = 518
	PostgreSQLParserRULE_having_clause                     = 519
	PostgreSQLParserRULE_for_locking_clause                = 520
	PostgreSQLParserRULE_opt_for_locking_clause            = 521
	PostgreSQLParserRULE_for_locking_items                 = 522
	PostgreSQLParserRULE_for_locking_item                  = 523
	PostgreSQLParserRULE_for_locking_strength              = 524
	PostgreSQLParserRULE_locked_rels_list                  = 525
	PostgreSQLParserRULE_values_clause                     = 526
	PostgreSQLParserRULE_from_clause                       = 527
	PostgreSQLParserRULE_from_list                         = 528
	PostgreSQLParserRULE_non_ansi_join                     = 529
	PostgreSQLParserRULE_table_ref                         = 530
	PostgreSQLParserRULE_alias_clause                      = 531
	PostgreSQLParserRULE_opt_alias_clause                  = 532
	PostgreSQLParserRULE_table_alias_clause                = 533
	PostgreSQLParserRULE_func_alias_clause                 = 534
	PostgreSQLParserRULE_join_type                         = 535
	PostgreSQLParserRULE_join_qual                         = 536
	PostgreSQLParserRULE_relation_expr                     = 537
	PostgreSQLParserRULE_relation_expr_list                = 538
	PostgreSQLParserRULE_relation_expr_opt_alias           = 539
	PostgreSQLParserRULE_tablesample_clause                = 540
	PostgreSQLParserRULE_opt_repeatable_clause             = 541
	PostgreSQLParserRULE_func_table                        = 542
	PostgreSQLParserRULE_rowsfrom_item                     = 543
	PostgreSQLParserRULE_rowsfrom_list                     = 544
	PostgreSQLParserRULE_opt_col_def_list                  = 545
	PostgreSQLParserRULE_opt_ordinality                    = 546
	PostgreSQLParserRULE_where_clause                      = 547
	PostgreSQLParserRULE_where_or_current_clause           = 548
	PostgreSQLParserRULE_opttablefuncelementlist           = 549
	PostgreSQLParserRULE_tablefuncelementlist              = 550
	PostgreSQLParserRULE_tablefuncelement                  = 551
	PostgreSQLParserRULE_xmltable                          = 552
	PostgreSQLParserRULE_xmltable_column_list              = 553
	PostgreSQLParserRULE_xmltable_column_el                = 554
	PostgreSQLParserRULE_xmltable_column_option_list       = 555
	PostgreSQLParserRULE_xmltable_column_option_el         = 556
	PostgreSQLParserRULE_xml_namespace_list                = 557
	PostgreSQLParserRULE_xml_namespace_el                  = 558
	PostgreSQLParserRULE_typename                          = 559
	PostgreSQLParserRULE_opt_array_bounds                  = 560
	PostgreSQLParserRULE_simpletypename                    = 561
	PostgreSQLParserRULE_consttypename                     = 562
	PostgreSQLParserRULE_generictype                       = 563
	PostgreSQLParserRULE_opt_type_modifiers                = 564
	PostgreSQLParserRULE_numeric                           = 565
	PostgreSQLParserRULE_opt_float                         = 566
	PostgreSQLParserRULE_bit                               = 567
	PostgreSQLParserRULE_constbit                          = 568
	PostgreSQLParserRULE_bitwithlength                     = 569
	PostgreSQLParserRULE_bitwithoutlength                  = 570
	PostgreSQLParserRULE_character                         = 571
	PostgreSQLParserRULE_constcharacter                    = 572
	PostgreSQLParserRULE_character_c                       = 573
	PostgreSQLParserRULE_opt_varying                       = 574
	PostgreSQLParserRULE_constdatetime                     = 575
	PostgreSQLParserRULE_constinterval                     = 576
	PostgreSQLParserRULE_opt_timezone                      = 577
	PostgreSQLParserRULE_opt_interval                      = 578
	PostgreSQLParserRULE_interval_second                   = 579
	PostgreSQLParserRULE_opt_escape                        = 580
	PostgreSQLParserRULE_a_expr                            = 581
	PostgreSQLParserRULE_a_expr_qual                       = 582
	PostgreSQLParserRULE_a_expr_lessless                   = 583
	PostgreSQLParserRULE_a_expr_or                         = 584
	PostgreSQLParserRULE_a_expr_and                        = 585
	PostgreSQLParserRULE_a_expr_between                    = 586
	PostgreSQLParserRULE_a_expr_in                         = 587
	PostgreSQLParserRULE_a_expr_unary_not                  = 588
	PostgreSQLParserRULE_a_expr_isnull                     = 589
	PostgreSQLParserRULE_a_expr_is_not                     = 590
	PostgreSQLParserRULE_a_expr_compare                    = 591
	PostgreSQLParserRULE_a_expr_like                       = 592
	PostgreSQLParserRULE_a_expr_qual_op                    = 593
	PostgreSQLParserRULE_a_expr_unary_qualop               = 594
	PostgreSQLParserRULE_a_expr_add                        = 595
	PostgreSQLParserRULE_a_expr_mul                        = 596
	PostgreSQLParserRULE_a_expr_caret                      = 597
	PostgreSQLParserRULE_a_expr_unary_sign                 = 598
	PostgreSQLParserRULE_a_expr_at_time_zone               = 599
	PostgreSQLParserRULE_a_expr_collate                    = 600
	PostgreSQLParserRULE_a_expr_typecast                   = 601
	PostgreSQLParserRULE_b_expr                            = 602
	PostgreSQLParserRULE_c_expr                            = 603
	PostgreSQLParserRULE_plsqlvariablename                 = 604
	PostgreSQLParserRULE_func_application                  = 605
	PostgreSQLParserRULE_func_expr                         = 606
	PostgreSQLParserRULE_func_expr_windowless              = 607
	PostgreSQLParserRULE_func_expr_common_subexpr          = 608
	PostgreSQLParserRULE_xml_root_version                  = 609
	PostgreSQLParserRULE_opt_xml_root_standalone           = 610
	PostgreSQLParserRULE_xml_attributes                    = 611
	PostgreSQLParserRULE_xml_attribute_list                = 612
	PostgreSQLParserRULE_xml_attribute_el                  = 613
	PostgreSQLParserRULE_document_or_content               = 614
	PostgreSQLParserRULE_xml_whitespace_option             = 615
	PostgreSQLParserRULE_xmlexists_argument                = 616
	PostgreSQLParserRULE_xml_passing_mech                  = 617
	PostgreSQLParserRULE_within_group_clause               = 618
	PostgreSQLParserRULE_filter_clause                     = 619
	PostgreSQLParserRULE_window_clause                     = 620
	PostgreSQLParserRULE_window_definition_list            = 621
	PostgreSQLParserRULE_window_definition                 = 622
	PostgreSQLParserRULE_over_clause                       = 623
	PostgreSQLParserRULE_window_specification              = 624
	PostgreSQLParserRULE_opt_existing_window_name          = 625
	PostgreSQLParserRULE_opt_partition_clause              = 626
	PostgreSQLParserRULE_opt_frame_clause                  = 627
	PostgreSQLParserRULE_frame_extent                      = 628
	PostgreSQLParserRULE_frame_bound                       = 629
	PostgreSQLParserRULE_opt_window_exclusion_clause       = 630
	PostgreSQLParserRULE_row                               = 631
	PostgreSQLParserRULE_explicit_row                      = 632
	PostgreSQLParserRULE_implicit_row                      = 633
	PostgreSQLParserRULE_sub_type                          = 634
	PostgreSQLParserRULE_all_op                            = 635
	PostgreSQLParserRULE_mathop                            = 636
	PostgreSQLParserRULE_qual_op                           = 637
	PostgreSQLParserRULE_qual_all_op                       = 638
	PostgreSQLParserRULE_subquery_Op                       = 639
	PostgreSQLParserRULE_expr_list                         = 640
	PostgreSQLParserRULE_func_arg_list                     = 641
	PostgreSQLParserRULE_func_arg_expr                     = 642
	PostgreSQLParserRULE_type_list                         = 643
	PostgreSQLParserRULE_array_expr                        = 644
	PostgreSQLParserRULE_array_expr_list                   = 645
	PostgreSQLParserRULE_extract_list                      = 646
	PostgreSQLParserRULE_extract_arg                       = 647
	PostgreSQLParserRULE_unicode_normal_form               = 648
	PostgreSQLParserRULE_overlay_list                      = 649
	PostgreSQLParserRULE_position_list                     = 650
	PostgreSQLParserRULE_substr_list                       = 651
	PostgreSQLParserRULE_trim_list                         = 652
	PostgreSQLParserRULE_in_expr                           = 653
	PostgreSQLParserRULE_case_expr                         = 654
	PostgreSQLParserRULE_when_clause_list                  = 655
	PostgreSQLParserRULE_when_clause                       = 656
	PostgreSQLParserRULE_case_default                      = 657
	PostgreSQLParserRULE_case_arg                          = 658
	PostgreSQLParserRULE_columnref                         = 659
	PostgreSQLParserRULE_indirection_el                    = 660
	PostgreSQLParserRULE_opt_slice_bound                   = 661
	PostgreSQLParserRULE_indirection                       = 662
	PostgreSQLParserRULE_opt_indirection                   = 663
	PostgreSQLParserRULE_opt_target_list                   = 664
	PostgreSQLParserRULE_target_list                       = 665
	PostgreSQLParserRULE_target_el                         = 666
	PostgreSQLParserRULE_qualified_name_list               = 667
	PostgreSQLParserRULE_qualified_name                    = 668
	PostgreSQLParserRULE_name_list                         = 669
	PostgreSQLParserRULE_name                              = 670
	PostgreSQLParserRULE_attr_name                         = 671
	PostgreSQLParserRULE_file_name                         = 672
	PostgreSQLParserRULE_func_name                         = 673
	PostgreSQLParserRULE_aexprconst                        = 674
	PostgreSQLParserRULE_xconst                            = 675
	PostgreSQLParserRULE_bconst                            = 676
	PostgreSQLParserRULE_fconst                            = 677
	PostgreSQLParserRULE_iconst                            = 678
	PostgreSQLParserRULE_sconst                            = 679
	PostgreSQLParserRULE_anysconst                         = 680
	PostgreSQLParserRULE_opt_uescape                       = 681
	PostgreSQLParserRULE_signediconst                      = 682
	PostgreSQLParserRULE_roleid                            = 683
	PostgreSQLParserRULE_rolespec                          = 684
	PostgreSQLParserRULE_role_list                         = 685
	PostgreSQLParserRULE_colid                             = 686
	PostgreSQLParserRULE_table_alias                       = 687
	PostgreSQLParserRULE_type_function_name                = 688
	PostgreSQLParserRULE_nonreservedword                   = 689
	PostgreSQLParserRULE_collabel                          = 690
	PostgreSQLParserRULE_identifier                        = 691
	PostgreSQLParserRULE_plsqlidentifier                   = 692
	PostgreSQLParserRULE_unreserved_keyword                = 693
	PostgreSQLParserRULE_col_name_keyword                  = 694
	PostgreSQLParserRULE_type_func_name_keyword            = 695
	PostgreSQLParserRULE_reserved_keyword                  = 696
	PostgreSQLParserRULE_builtin_function_name             = 697
	PostgreSQLParserRULE_pl_function                       = 698
	PostgreSQLParserRULE_comp_options                      = 699
	PostgreSQLParserRULE_comp_option                       = 700
	PostgreSQLParserRULE_sharp                             = 701
	PostgreSQLParserRULE_option_value                      = 702
	PostgreSQLParserRULE_opt_semi                          = 703
	PostgreSQLParserRULE_pl_block                          = 704
	PostgreSQLParserRULE_decl_sect                         = 705
	PostgreSQLParserRULE_decl_start                        = 706
	PostgreSQLParserRULE_decl_stmts                        = 707
	PostgreSQLParserRULE_label_decl                        = 708
	PostgreSQLParserRULE_decl_stmt                         = 709
	PostgreSQLParserRULE_decl_statement                    = 710
	PostgreSQLParserRULE_opt_scrollable                    = 711
	PostgreSQLParserRULE_decl_cursor_query                 = 712
	PostgreSQLParserRULE_decl_cursor_args                  = 713
	PostgreSQLParserRULE_decl_cursor_arglist               = 714
	PostgreSQLParserRULE_decl_cursor_arg                   = 715
	PostgreSQLParserRULE_decl_is_for                       = 716
	PostgreSQLParserRULE_decl_aliasitem                    = 717
	PostgreSQLParserRULE_decl_varname                      = 718
	PostgreSQLParserRULE_decl_const                        = 719
	PostgreSQLParserRULE_decl_datatype                     = 720
	PostgreSQLParserRULE_decl_collate                      = 721
	PostgreSQLParserRULE_decl_notnull                      = 722
	PostgreSQLParserRULE_decl_defval                       = 723
	PostgreSQLParserRULE_decl_defkey                       = 724
	PostgreSQLParserRULE_assign_operator                   = 725
	PostgreSQLParserRULE_proc_sect                         = 726
	PostgreSQLParserRULE_proc_stmt                         = 727
	PostgreSQLParserRULE_stmt_perform                      = 728
	PostgreSQLParserRULE_stmt_call                         = 729
	PostgreSQLParserRULE_opt_expr_list                     = 730
	PostgreSQLParserRULE_stmt_assign                       = 731
	PostgreSQLParserRULE_stmt_getdiag                      = 732
	PostgreSQLParserRULE_getdiag_area_opt                  = 733
	PostgreSQLParserRULE_getdiag_list                      = 734
	PostgreSQLParserRULE_getdiag_list_item                 = 735
	PostgreSQLParserRULE_getdiag_item                      = 736
	PostgreSQLParserRULE_getdiag_target                    = 737
	PostgreSQLParserRULE_assign_var                        = 738
	PostgreSQLParserRULE_stmt_if                           = 739
	PostgreSQLParserRULE_stmt_elsifs                       = 740
	PostgreSQLParserRULE_stmt_else                         = 741
	PostgreSQLParserRULE_stmt_case                         = 742
	PostgreSQLParserRULE_opt_expr_until_when               = 743
	PostgreSQLParserRULE_case_when_list                    = 744
	PostgreSQLParserRULE_case_when                         = 745
	PostgreSQLParserRULE_opt_case_else                     = 746
	PostgreSQLParserRULE_stmt_loop                         = 747
	PostgreSQLParserRULE_stmt_while                        = 748
	PostgreSQLParserRULE_stmt_for                          = 749
	PostgreSQLParserRULE_for_control                       = 750
	PostgreSQLParserRULE_opt_for_using_expression          = 751
	PostgreSQLParserRULE_opt_cursor_parameters             = 752
	PostgreSQLParserRULE_opt_reverse                       = 753
	PostgreSQLParserRULE_opt_by_expression                 = 754
	PostgreSQLParserRULE_for_variable                      = 755
	PostgreSQLParserRULE_stmt_foreach_a                    = 756
	PostgreSQLParserRULE_foreach_slice                     = 757
	PostgreSQLParserRULE_stmt_exit                         = 758
	PostgreSQLParserRULE_exit_type                         = 759
	PostgreSQLParserRULE_stmt_return                       = 760
	PostgreSQLParserRULE_opt_return_result                 = 761
	PostgreSQLParserRULE_stmt_raise                        = 762
	PostgreSQLParserRULE_opt_stmt_raise_level              = 763
	PostgreSQLParserRULE_opt_raise_list                    = 764
	PostgreSQLParserRULE_opt_raise_using                   = 765
	PostgreSQLParserRULE_opt_raise_using_elem              = 766
	PostgreSQLParserRULE_opt_raise_using_elem_list         = 767
	PostgreSQLParserRULE_stmt_assert                       = 768
	PostgreSQLParserRULE_opt_stmt_assert_message           = 769
	PostgreSQLParserRULE_loop_body                         = 770
	PostgreSQLParserRULE_stmt_execsql                      = 771
	PostgreSQLParserRULE_stmt_dynexecute                   = 772
	PostgreSQLParserRULE_opt_execute_using                 = 773
	PostgreSQLParserRULE_opt_execute_using_list            = 774
	PostgreSQLParserRULE_opt_execute_into                  = 775
	PostgreSQLParserRULE_stmt_open                         = 776
	PostgreSQLParserRULE_opt_open_bound_list_item          = 777
	PostgreSQLParserRULE_opt_open_bound_list               = 778
	PostgreSQLParserRULE_opt_open_using                    = 779
	PostgreSQLParserRULE_opt_scroll_option                 = 780
	PostgreSQLParserRULE_opt_scroll_option_no              = 781
	PostgreSQLParserRULE_stmt_fetch                        = 782
	PostgreSQLParserRULE_into_target                       = 783
	PostgreSQLParserRULE_opt_cursor_from                   = 784
	PostgreSQLParserRULE_opt_fetch_direction               = 785
	PostgreSQLParserRULE_stmt_move                         = 786
	PostgreSQLParserRULE_stmt_close                        = 787
	PostgreSQLParserRULE_stmt_null                         = 788
	PostgreSQLParserRULE_stmt_commit                       = 789
	PostgreSQLParserRULE_stmt_rollback                     = 790
	PostgreSQLParserRULE_plsql_opt_transaction_chain       = 791
	PostgreSQLParserRULE_stmt_set                          = 792
	PostgreSQLParserRULE_cursor_variable                   = 793
	PostgreSQLParserRULE_exception_sect                    = 794
	PostgreSQLParserRULE_proc_exceptions                   = 795
	PostgreSQLParserRULE_proc_exception                    = 796
	PostgreSQLParserRULE_proc_conditions                   = 797
	PostgreSQLParserRULE_proc_condition                    = 798
	PostgreSQLParserRULE_opt_block_label                   = 799
	PostgreSQLParserRULE_opt_loop_label                    = 800
	PostgreSQLParserRULE_opt_label                         = 801
	PostgreSQLParserRULE_opt_exitcond                      = 802
	PostgreSQLParserRULE_any_identifier                    = 803
	PostgreSQLParserRULE_plsql_unreserved_keyword          = 804
	PostgreSQLParserRULE_sql_expression                    = 805
	PostgreSQLParserRULE_expr_until_then                   = 806
	PostgreSQLParserRULE_expr_until_semi                   = 807
	PostgreSQLParserRULE_expr_until_rightbracket           = 808
	PostgreSQLParserRULE_expr_until_loop                   = 809
	PostgreSQLParserRULE_make_execsql_stmt                 = 810
	PostgreSQLParserRULE_opt_returning_clause_into         = 811
)

// IRootContext is an interface to support dynamic dispatch.
type IRootContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Stmtblock() IStmtblockContext
	EOF() antlr.TerminalNode

	// IsRootContext differentiates from other interfaces.
	IsRootContext()
}

type RootContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyRootContext() *RootContext {
	var p = new(RootContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_root
	return p
}

func InitEmptyRootContext(p *RootContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_root
}

func (*RootContext) IsRootContext() {}

func NewRootContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *RootContext {
	var p = new(RootContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_root

	return p
}

func (s *RootContext) GetParser() antlr.Parser { return s.parser }

func (s *RootContext) Stmtblock() IStmtblockContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IStmtblockContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IStmtblockContext)
}

func (s *RootContext) EOF() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserEOF, 0)
}

func (s *RootContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *RootContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *RootContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterRoot(s)
	}
}

func (s *RootContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitRoot(s)
	}
}

func (s *RootContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitRoot(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Root() (localctx IRootContext) {
	localctx = NewRootContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 0, PostgreSQLParserRULE_root)
	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1624)
		p.Stmtblock()
	}
	{
		p.SetState(1625)
		p.Match(PostgreSQLParserEOF)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IPlsqlrootContext is an interface to support dynamic dispatch.
type IPlsqlrootContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Pl_function() IPl_functionContext

	// IsPlsqlrootContext differentiates from other interfaces.
	IsPlsqlrootContext()
}

type PlsqlrootContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyPlsqlrootContext() *PlsqlrootContext {
	var p = new(PlsqlrootContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_plsqlroot
	return p
}

func InitEmptyPlsqlrootContext(p *PlsqlrootContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_plsqlroot
}

func (*PlsqlrootContext) IsPlsqlrootContext() {}

func NewPlsqlrootContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *PlsqlrootContext {
	var p = new(PlsqlrootContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_plsqlroot

	return p
}

func (s *PlsqlrootContext) GetParser() antlr.Parser { return s.parser }

func (s *PlsqlrootContext) Pl_function() IPl_functionContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IPl_functionContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IPl_functionContext)
}

func (s *PlsqlrootContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *PlsqlrootContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *PlsqlrootContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterPlsqlroot(s)
	}
}

func (s *PlsqlrootContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitPlsqlroot(s)
	}
}

func (s *PlsqlrootContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitPlsqlroot(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Plsqlroot() (localctx IPlsqlrootContext) {
	localctx = NewPlsqlrootContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 2, PostgreSQLParserRULE_plsqlroot)
	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1627)
		p.Pl_function()
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IStmtblockContext is an interface to support dynamic dispatch.
type IStmtblockContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Stmtmulti() IStmtmultiContext

	// IsStmtblockContext differentiates from other interfaces.
	IsStmtblockContext()
}

type StmtblockContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyStmtblockContext() *StmtblockContext {
	var p = new(StmtblockContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_stmtblock
	return p
}

func InitEmptyStmtblockContext(p *StmtblockContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_stmtblock
}

func (*StmtblockContext) IsStmtblockContext() {}

func NewStmtblockContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *StmtblockContext {
	var p = new(StmtblockContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_stmtblock

	return p
}

func (s *StmtblockContext) GetParser() antlr.Parser { return s.parser }

func (s *StmtblockContext) Stmtmulti() IStmtmultiContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IStmtmultiContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IStmtmultiContext)
}

func (s *StmtblockContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *StmtblockContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *StmtblockContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterStmtblock(s)
	}
}

func (s *StmtblockContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitStmtblock(s)
	}
}

func (s *StmtblockContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitStmtblock(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Stmtblock() (localctx IStmtblockContext) {
	localctx = NewStmtblockContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 4, PostgreSQLParserRULE_stmtblock)
	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1629)
		p.Stmtmulti()
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IStmtmultiContext is an interface to support dynamic dispatch.
type IStmtmultiContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	AllStmt() []IStmtContext
	Stmt(i int) IStmtContext
	AllSEMI() []antlr.TerminalNode
	SEMI(i int) antlr.TerminalNode

	// IsStmtmultiContext differentiates from other interfaces.
	IsStmtmultiContext()
}

type StmtmultiContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyStmtmultiContext() *StmtmultiContext {
	var p = new(StmtmultiContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_stmtmulti
	return p
}

func InitEmptyStmtmultiContext(p *StmtmultiContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_stmtmulti
}

func (*StmtmultiContext) IsStmtmultiContext() {}

func NewStmtmultiContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *StmtmultiContext {
	var p = new(StmtmultiContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_stmtmulti

	return p
}

func (s *StmtmultiContext) GetParser() antlr.Parser { return s.parser }

func (s *StmtmultiContext) AllStmt() []IStmtContext {
	children := s.GetChildren()
	len := 0
	for _, ctx := range children {
		if _, ok := ctx.(IStmtContext); ok {
			len++
		}
	}

	tst := make([]IStmtContext, len)
	i := 0
	for _, ctx := range children {
		if t, ok := ctx.(IStmtContext); ok {
			tst[i] = t.(IStmtContext)
			i++
		}
	}

	return tst
}

func (s *StmtmultiContext) Stmt(i int) IStmtContext {
	var t antlr.RuleContext
	j := 0
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IStmtContext); ok {
			if j == i {
				t = ctx.(antlr.RuleContext)
				break
			}
			j++
		}
	}

	if t == nil {
		return nil
	}

	return t.(IStmtContext)
}

func (s *StmtmultiContext) AllSEMI() []antlr.TerminalNode {
	return s.GetTokens(PostgreSQLParserSEMI)
}

func (s *StmtmultiContext) SEMI(i int) antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserSEMI, i)
}

func (s *StmtmultiContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *StmtmultiContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *StmtmultiContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterStmtmulti(s)
	}
}

func (s *StmtmultiContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitStmtmulti(s)
	}
}

func (s *StmtmultiContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitStmtmulti(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Stmtmulti() (localctx IStmtmultiContext) {
	localctx = NewStmtmultiContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 6, PostgreSQLParserRULE_stmtmulti)
	var _la int

	p.EnterOuterAlt(localctx, 1)
	p.SetState(1637)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}
	_la = p.GetTokenStream().LA(1)

	for ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&2450028572476178436) != 0) || ((int64((_la-65)) & ^0x3f) == 0 && ((int64(1)<<(_la-65))&1099654234113) != 0) || ((int64((_la-129)) & ^0x3f) == 0 && ((int64(1)<<(_la-129))&4909769124516856321) != 0) || ((int64((_la-202)) & ^0x3f) == 0 && ((int64(1)<<(_la-202))&4686037194794598403) != 0) || ((int64((_la-283)) & ^0x3f) == 0 && ((int64(1)<<(_la-283))&1170022785714177) != 0) || ((int64((_la-351)) & ^0x3f) == 0 && ((int64(1)<<(_la-351))&6401) != 0) || ((int64((_la-415)) & ^0x3f) == 0 && ((int64(1)<<(_la-415))&550292946945) != 0) || _la == PostgreSQLParserMetaCommand {
		{
			p.SetState(1631)
			p.Stmt()
		}
		p.SetState(1633)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}
		_la = p.GetTokenStream().LA(1)

		if _la == PostgreSQLParserSEMI {
			{
				p.SetState(1632)
				p.Match(PostgreSQLParserSEMI)
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}

		}

		p.SetState(1639)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}
		_la = p.GetTokenStream().LA(1)
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IStmtContext is an interface to support dynamic dispatch.
type IStmtContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Altereventtrigstmt() IAltereventtrigstmtContext
	Altercollationstmt() IAltercollationstmtContext
	Alterdatabasestmt() IAlterdatabasestmtContext
	Alterdatabasesetstmt() IAlterdatabasesetstmtContext
	Alterdefaultprivilegesstmt() IAlterdefaultprivilegesstmtContext
	Alterdomainstmt() IAlterdomainstmtContext
	Alterenumstmt() IAlterenumstmtContext
	Alterextensionstmt() IAlterextensionstmtContext
	Alterextensioncontentsstmt() IAlterextensioncontentsstmtContext
	Alterfdwstmt() IAlterfdwstmtContext
	Alterforeignserverstmt() IAlterforeignserverstmtContext
	Alterfunctionstmt() IAlterfunctionstmtContext
	Altergroupstmt() IAltergroupstmtContext
	Alterobjectdependsstmt() IAlterobjectdependsstmtContext
	Alterobjectschemastmt() IAlterobjectschemastmtContext
	Alterownerstmt() IAlterownerstmtContext
	Alteroperatorstmt() IAlteroperatorstmtContext
	Altertypestmt() IAltertypestmtContext
	Alterpolicystmt() IAlterpolicystmtContext
	Alterseqstmt() IAlterseqstmtContext
	Altersystemstmt() IAltersystemstmtContext
	Altertablestmt() IAltertablestmtContext
	Altertblspcstmt() IAltertblspcstmtContext
	Altercompositetypestmt() IAltercompositetypestmtContext
	Alterpublicationstmt() IAlterpublicationstmtContext
	Alterrolesetstmt() IAlterrolesetstmtContext
	Alterrolestmt() IAlterrolestmtContext
	Altersubscriptionstmt() IAltersubscriptionstmtContext
	Alterstatsstmt() IAlterstatsstmtContext
	Altertsconfigurationstmt() IAltertsconfigurationstmtContext
	Altertsdictionarystmt() IAltertsdictionarystmtContext
	Alterusermappingstmt() IAlterusermappingstmtContext
	Analyzestmt() IAnalyzestmtContext
	Callstmt() ICallstmtContext
	Checkpointstmt() ICheckpointstmtContext
	Closeportalstmt() ICloseportalstmtContext
	Clusterstmt() IClusterstmtContext
	Commentstmt() ICommentstmtContext
	Constraintssetstmt() IConstraintssetstmtContext
	Copystmt() ICopystmtContext
	Createamstmt() ICreateamstmtContext
	Createasstmt() ICreateasstmtContext
	Createassertionstmt() ICreateassertionstmtContext
	Createcaststmt() ICreatecaststmtContext
	Createconversionstmt() ICreateconversionstmtContext
	Createdomainstmt() ICreatedomainstmtContext
	Createextensionstmt() ICreateextensionstmtContext
	Createfdwstmt() ICreatefdwstmtContext
	Createforeignserverstmt() ICreateforeignserverstmtContext
	Createforeigntablestmt() ICreateforeigntablestmtContext
	Createfunctionstmt() ICreatefunctionstmtContext
	Creategroupstmt() ICreategroupstmtContext
	Creatematviewstmt() ICreatematviewstmtContext
	Createopclassstmt() ICreateopclassstmtContext
	Createopfamilystmt() ICreateopfamilystmtContext
	Createpublicationstmt() ICreatepublicationstmtContext
	Alteropfamilystmt() IAlteropfamilystmtContext
	Createpolicystmt() ICreatepolicystmtContext
	Createplangstmt() ICreateplangstmtContext
	Createschemastmt() ICreateschemastmtContext
	Createseqstmt() ICreateseqstmtContext
	Createstmt() ICreatestmtContext
	Createsubscriptionstmt() ICreatesubscriptionstmtContext
	Createstatsstmt() ICreatestatsstmtContext
	Createtablespacestmt() ICreatetablespacestmtContext
	Createtransformstmt() ICreatetransformstmtContext
	Createtrigstmt() ICreatetrigstmtContext
	Createeventtrigstmt() ICreateeventtrigstmtContext
	Createrolestmt() ICreaterolestmtContext
	Createuserstmt() ICreateuserstmtContext
	Createusermappingstmt() ICreateusermappingstmtContext
	Createdbstmt() ICreatedbstmtContext
	Deallocatestmt() IDeallocatestmtContext
	Declarecursorstmt() IDeclarecursorstmtContext
	Definestmt() IDefinestmtContext
	Deletestmt() IDeletestmtContext
	Discardstmt() IDiscardstmtContext
	Dostmt() IDostmtContext
	Dropcaststmt() IDropcaststmtContext
	Dropopclassstmt() IDropopclassstmtContext
	Dropopfamilystmt() IDropopfamilystmtContext
	Dropownedstmt() IDropownedstmtContext
	Dropstmt() IDropstmtContext
	Dropsubscriptionstmt() IDropsubscriptionstmtContext
	Droptablespacestmt() IDroptablespacestmtContext
	Droptransformstmt() IDroptransformstmtContext
	Droprolestmt() IDroprolestmtContext
	Dropusermappingstmt() IDropusermappingstmtContext
	Dropdbstmt() IDropdbstmtContext
	Executestmt() IExecutestmtContext
	Explainstmt() IExplainstmtContext
	Fetchstmt() IFetchstmtContext
	Grantstmt() IGrantstmtContext
	Grantrolestmt() IGrantrolestmtContext
	Importforeignschemastmt() IImportforeignschemastmtContext
	Indexstmt() IIndexstmtContext
	Insertstmt() IInsertstmtContext
	Mergestmt() IMergestmtContext
	Listenstmt() IListenstmtContext
	Refreshmatviewstmt() IRefreshmatviewstmtContext
	Loadstmt() ILoadstmtContext
	Lockstmt() ILockstmtContext
	Notifystmt() INotifystmtContext
	Preparestmt() IPreparestmtContext
	Reassignownedstmt() IReassignownedstmtContext
	Reindexstmt() IReindexstmtContext
	Removeaggrstmt() IRemoveaggrstmtContext
	Removefuncstmt() IRemovefuncstmtContext
	Removeoperstmt() IRemoveoperstmtContext
	Renamestmt() IRenamestmtContext
	Revokestmt() IRevokestmtContext
	Revokerolestmt() IRevokerolestmtContext
	Rulestmt() IRulestmtContext
	Seclabelstmt() ISeclabelstmtContext
	Selectstmt() ISelectstmtContext
	Transactionstmt() ITransactionstmtContext
	Truncatestmt() ITruncatestmtContext
	Unlistenstmt() IUnlistenstmtContext
	Updatestmt() IUpdatestmtContext
	Vacuumstmt() IVacuumstmtContext
	Variableresetstmt() IVariableresetstmtContext
	Variablesetstmt() IVariablesetstmtContext
	Variableshowstmt() IVariableshowstmtContext
	Viewstmt() IViewstmtContext
	Plsqlconsolecommand() IPlsqlconsolecommandContext

	// IsStmtContext differentiates from other interfaces.
	IsStmtContext()
}

type StmtContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyStmtContext() *StmtContext {
	var p = new(StmtContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_stmt
	return p
}

func InitEmptyStmtContext(p *StmtContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_stmt
}

func (*StmtContext) IsStmtContext() {}

func NewStmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *StmtContext {
	var p = new(StmtContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_stmt

	return p
}

func (s *StmtContext) GetParser() antlr.Parser { return s.parser }

func (s *StmtContext) Altereventtrigstmt() IAltereventtrigstmtContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IAltereventtrigstmtContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IAltereventtrigstmtContext)
}

func (s *StmtContext) Altercollationstmt() IAltercollationstmtContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IAltercollationstmtContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IAltercollationstmtContext)
}

func (s *StmtContext) Alterdatabasestmt() IAlterdatabasestmtContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IAlterdatabasestmtContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IAlterdatabasestmtContext)
}

func (s *StmtContext) Alterdatabasesetstmt() IAlterdatabasesetstmtContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IAlterdatabasesetstmtContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IAlterdatabasesetstmtContext)
}

func (s *StmtContext) Alterdefaultprivilegesstmt() IAlterdefaultprivilegesstmtContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IAlterdefaultprivilegesstmtContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IAlterdefaultprivilegesstmtContext)
}

func (s *StmtContext) Alterdomainstmt() IAlterdomainstmtContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IAlterdomainstmtContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IAlterdomainstmtContext)
}

func (s *StmtContext) Alterenumstmt() IAlterenumstmtContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IAlterenumstmtContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IAlterenumstmtContext)
}

func (s *StmtContext) Alterextensionstmt() IAlterextensionstmtContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IAlterextensionstmtContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IAlterextensionstmtContext)
}

func (s *StmtContext) Alterextensioncontentsstmt() IAlterextensioncontentsstmtContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IAlterextensioncontentsstmtContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IAlterextensioncontentsstmtContext)
}

func (s *StmtContext) Alterfdwstmt() IAlterfdwstmtContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IAlterfdwstmtContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IAlterfdwstmtContext)
}

func (s *StmtContext) Alterforeignserverstmt() IAlterforeignserverstmtContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IAlterforeignserverstmtContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IAlterforeignserverstmtContext)
}

func (s *StmtContext) Alterfunctionstmt() IAlterfunctionstmtContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IAlterfunctionstmtContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IAlterfunctionstmtContext)
}

func (s *StmtContext) Altergroupstmt() IAltergroupstmtContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IAltergroupstmtContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IAltergroupstmtContext)
}

func (s *StmtContext) Alterobjectdependsstmt() IAlterobjectdependsstmtContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IAlterobjectdependsstmtContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IAlterobjectdependsstmtContext)
}

func (s *StmtContext) Alterobjectschemastmt() IAlterobjectschemastmtContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IAlterobjectschemastmtContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IAlterobjectschemastmtContext)
}

func (s *StmtContext) Alterownerstmt() IAlterownerstmtContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IAlterownerstmtContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IAlterownerstmtContext)
}

func (s *StmtContext) Alteroperatorstmt() IAlteroperatorstmtContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IAlteroperatorstmtContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IAlteroperatorstmtContext)
}

func (s *StmtContext) Altertypestmt() IAltertypestmtContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IAltertypestmtContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IAltertypestmtContext)
}

func (s *StmtContext) Alterpolicystmt() IAlterpolicystmtContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IAlterpolicystmtContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IAlterpolicystmtContext)
}

func (s *StmtContext) Alterseqstmt() IAlterseqstmtContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IAlterseqstmtContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IAlterseqstmtContext)
}

func (s *StmtContext) Altersystemstmt() IAltersystemstmtContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IAltersystemstmtContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IAltersystemstmtContext)
}

func (s *StmtContext) Altertablestmt() IAltertablestmtContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IAltertablestmtContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IAltertablestmtContext)
}

func (s *StmtContext) Altertblspcstmt() IAltertblspcstmtContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IAltertblspcstmtContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IAltertblspcstmtContext)
}

func (s *StmtContext) Altercompositetypestmt() IAltercompositetypestmtContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IAltercompositetypestmtContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IAltercompositetypestmtContext)
}

func (s *StmtContext) Alterpublicationstmt() IAlterpublicationstmtContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IAlterpublicationstmtContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IAlterpublicationstmtContext)
}

func (s *StmtContext) Alterrolesetstmt() IAlterrolesetstmtContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IAlterrolesetstmtContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IAlterrolesetstmtContext)
}

func (s *StmtContext) Alterrolestmt() IAlterrolestmtContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IAlterrolestmtContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IAlterrolestmtContext)
}

func (s *StmtContext) Altersubscriptionstmt() IAltersubscriptionstmtContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IAltersubscriptionstmtContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IAltersubscriptionstmtContext)
}

func (s *StmtContext) Alterstatsstmt() IAlterstatsstmtContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IAlterstatsstmtContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IAlterstatsstmtContext)
}

func (s *StmtContext) Altertsconfigurationstmt() IAltertsconfigurationstmtContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IAltertsconfigurationstmtContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IAltertsconfigurationstmtContext)
}

func (s *StmtContext) Altertsdictionarystmt() IAltertsdictionarystmtContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IAltertsdictionarystmtContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IAltertsdictionarystmtContext)
}

func (s *StmtContext) Alterusermappingstmt() IAlterusermappingstmtContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IAlterusermappingstmtContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IAlterusermappingstmtContext)
}

func (s *StmtContext) Analyzestmt() IAnalyzestmtContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IAnalyzestmtContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IAnalyzestmtContext)
}

func (s *StmtContext) Callstmt() ICallstmtContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ICallstmtContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ICallstmtContext)
}

func (s *StmtContext) Checkpointstmt() ICheckpointstmtContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ICheckpointstmtContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ICheckpointstmtContext)
}

func (s *StmtContext) Closeportalstmt() ICloseportalstmtContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ICloseportalstmtContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ICloseportalstmtContext)
}

func (s *StmtContext) Clusterstmt() IClusterstmtContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IClusterstmtContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IClusterstmtContext)
}

func (s *StmtContext) Commentstmt() ICommentstmtContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ICommentstmtContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ICommentstmtContext)
}

func (s *StmtContext) Constraintssetstmt() IConstraintssetstmtContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IConstraintssetstmtContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IConstraintssetstmtContext)
}

func (s *StmtContext) Copystmt() ICopystmtContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ICopystmtContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ICopystmtContext)
}

func (s *StmtContext) Createamstmt() ICreateamstmtContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ICreateamstmtContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ICreateamstmtContext)
}

func (s *StmtContext) Createasstmt() ICreateasstmtContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ICreateasstmtContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ICreateasstmtContext)
}

func (s *StmtContext) Createassertionstmt() ICreateassertionstmtContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ICreateassertionstmtContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ICreateassertionstmtContext)
}

func (s *StmtContext) Createcaststmt() ICreatecaststmtContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ICreatecaststmtContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ICreatecaststmtContext)
}

func (s *StmtContext) Createconversionstmt() ICreateconversionstmtContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ICreateconversionstmtContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ICreateconversionstmtContext)
}

func (s *StmtContext) Createdomainstmt() ICreatedomainstmtContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ICreatedomainstmtContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ICreatedomainstmtContext)
}

func (s *StmtContext) Createextensionstmt() ICreateextensionstmtContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ICreateextensionstmtContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ICreateextensionstmtContext)
}

func (s *StmtContext) Createfdwstmt() ICreatefdwstmtContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ICreatefdwstmtContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ICreatefdwstmtContext)
}

func (s *StmtContext) Createforeignserverstmt() ICreateforeignserverstmtContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ICreateforeignserverstmtContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ICreateforeignserverstmtContext)
}

func (s *StmtContext) Createforeigntablestmt() ICreateforeigntablestmtContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ICreateforeigntablestmtContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ICreateforeigntablestmtContext)
}

func (s *StmtContext) Createfunctionstmt() ICreatefunctionstmtContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ICreatefunctionstmtContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ICreatefunctionstmtContext)
}

func (s *StmtContext) Creategroupstmt() ICreategroupstmtContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ICreategroupstmtContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ICreategroupstmtContext)
}

func (s *StmtContext) Creatematviewstmt() ICreatematviewstmtContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ICreatematviewstmtContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ICreatematviewstmtContext)
}

func (s *StmtContext) Createopclassstmt() ICreateopclassstmtContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ICreateopclassstmtContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ICreateopclassstmtContext)
}

func (s *StmtContext) Createopfamilystmt() ICreateopfamilystmtContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ICreateopfamilystmtContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ICreateopfamilystmtContext)
}

func (s *StmtContext) Createpublicationstmt() ICreatepublicationstmtContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ICreatepublicationstmtContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ICreatepublicationstmtContext)
}

func (s *StmtContext) Alteropfamilystmt() IAlteropfamilystmtContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IAlteropfamilystmtContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IAlteropfamilystmtContext)
}

func (s *StmtContext) Createpolicystmt() ICreatepolicystmtContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ICreatepolicystmtContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ICreatepolicystmtContext)
}

func (s *StmtContext) Createplangstmt() ICreateplangstmtContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ICreateplangstmtContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ICreateplangstmtContext)
}

func (s *StmtContext) Createschemastmt() ICreateschemastmtContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ICreateschemastmtContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ICreateschemastmtContext)
}

func (s *StmtContext) Createseqstmt() ICreateseqstmtContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ICreateseqstmtContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ICreateseqstmtContext)
}

func (s *StmtContext) Createstmt() ICreatestmtContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ICreatestmtContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ICreatestmtContext)
}

func (s *StmtContext) Createsubscriptionstmt() ICreatesubscriptionstmtContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ICreatesubscriptionstmtContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ICreatesubscriptionstmtContext)
}

func (s *StmtContext) Createstatsstmt() ICreatestatsstmtContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ICreatestatsstmtContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ICreatestatsstmtContext)
}

func (s *StmtContext) Createtablespacestmt() ICreatetablespacestmtContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ICreatetablespacestmtContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ICreatetablespacestmtContext)
}

func (s *StmtContext) Createtransformstmt() ICreatetransformstmtContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ICreatetransformstmtContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ICreatetransformstmtContext)
}

func (s *StmtContext) Createtrigstmt() ICreatetrigstmtContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ICreatetrigstmtContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ICreatetrigstmtContext)
}

func (s *StmtContext) Createeventtrigstmt() ICreateeventtrigstmtContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ICreateeventtrigstmtContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ICreateeventtrigstmtContext)
}

func (s *StmtContext) Createrolestmt() ICreaterolestmtContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ICreaterolestmtContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ICreaterolestmtContext)
}

func (s *StmtContext) Createuserstmt() ICreateuserstmtContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ICreateuserstmtContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ICreateuserstmtContext)
}

func (s *StmtContext) Createusermappingstmt() ICreateusermappingstmtContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ICreateusermappingstmtContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ICreateusermappingstmtContext)
}

func (s *StmtContext) Createdbstmt() ICreatedbstmtContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ICreatedbstmtContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ICreatedbstmtContext)
}

func (s *StmtContext) Deallocatestmt() IDeallocatestmtContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IDeallocatestmtContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IDeallocatestmtContext)
}

func (s *StmtContext) Declarecursorstmt() IDeclarecursorstmtContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IDeclarecursorstmtContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IDeclarecursorstmtContext)
}

func (s *StmtContext) Definestmt() IDefinestmtContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IDefinestmtContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IDefinestmtContext)
}

func (s *StmtContext) Deletestmt() IDeletestmtContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IDeletestmtContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IDeletestmtContext)
}

func (s *StmtContext) Discardstmt() IDiscardstmtContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IDiscardstmtContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IDiscardstmtContext)
}

func (s *StmtContext) Dostmt() IDostmtContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IDostmtContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IDostmtContext)
}

func (s *StmtContext) Dropcaststmt() IDropcaststmtContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IDropcaststmtContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IDropcaststmtContext)
}

func (s *StmtContext) Dropopclassstmt() IDropopclassstmtContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IDropopclassstmtContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IDropopclassstmtContext)
}

func (s *StmtContext) Dropopfamilystmt() IDropopfamilystmtContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IDropopfamilystmtContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IDropopfamilystmtContext)
}

func (s *StmtContext) Dropownedstmt() IDropownedstmtContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IDropownedstmtContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IDropownedstmtContext)
}

func (s *StmtContext) Dropstmt() IDropstmtContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IDropstmtContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IDropstmtContext)
}

func (s *StmtContext) Dropsubscriptionstmt() IDropsubscriptionstmtContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IDropsubscriptionstmtContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IDropsubscriptionstmtContext)
}

func (s *StmtContext) Droptablespacestmt() IDroptablespacestmtContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IDroptablespacestmtContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IDroptablespacestmtContext)
}

func (s *StmtContext) Droptransformstmt() IDroptransformstmtContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IDroptransformstmtContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IDroptransformstmtContext)
}

func (s *StmtContext) Droprolestmt() IDroprolestmtContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IDroprolestmtContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IDroprolestmtContext)
}

func (s *StmtContext) Dropusermappingstmt() IDropusermappingstmtContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IDropusermappingstmtContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IDropusermappingstmtContext)
}

func (s *StmtContext) Dropdbstmt() IDropdbstmtContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IDropdbstmtContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IDropdbstmtContext)
}

func (s *StmtContext) Executestmt() IExecutestmtContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IExecutestmtContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IExecutestmtContext)
}

func (s *StmtContext) Explainstmt() IExplainstmtContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IExplainstmtContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IExplainstmtContext)
}

func (s *StmtContext) Fetchstmt() IFetchstmtContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IFetchstmtContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IFetchstmtContext)
}

func (s *StmtContext) Grantstmt() IGrantstmtContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IGrantstmtContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IGrantstmtContext)
}

func (s *StmtContext) Grantrolestmt() IGrantrolestmtContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IGrantrolestmtContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IGrantrolestmtContext)
}

func (s *StmtContext) Importforeignschemastmt() IImportforeignschemastmtContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IImportforeignschemastmtContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IImportforeignschemastmtContext)
}

func (s *StmtContext) Indexstmt() IIndexstmtContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IIndexstmtContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IIndexstmtContext)
}

func (s *StmtContext) Insertstmt() IInsertstmtContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IInsertstmtContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IInsertstmtContext)
}

func (s *StmtContext) Mergestmt() IMergestmtContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IMergestmtContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IMergestmtContext)
}

func (s *StmtContext) Listenstmt() IListenstmtContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IListenstmtContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IListenstmtContext)
}

func (s *StmtContext) Refreshmatviewstmt() IRefreshmatviewstmtContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IRefreshmatviewstmtContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IRefreshmatviewstmtContext)
}

func (s *StmtContext) Loadstmt() ILoadstmtContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ILoadstmtContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ILoadstmtContext)
}

func (s *StmtContext) Lockstmt() ILockstmtContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ILockstmtContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ILockstmtContext)
}

func (s *StmtContext) Notifystmt() INotifystmtContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(INotifystmtContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(INotifystmtContext)
}

func (s *StmtContext) Preparestmt() IPreparestmtContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IPreparestmtContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IPreparestmtContext)
}

func (s *StmtContext) Reassignownedstmt() IReassignownedstmtContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IReassignownedstmtContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IReassignownedstmtContext)
}

func (s *StmtContext) Reindexstmt() IReindexstmtContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IReindexstmtContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IReindexstmtContext)
}

func (s *StmtContext) Removeaggrstmt() IRemoveaggrstmtContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IRemoveaggrstmtContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IRemoveaggrstmtContext)
}

func (s *StmtContext) Removefuncstmt() IRemovefuncstmtContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IRemovefuncstmtContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IRemovefuncstmtContext)
}

func (s *StmtContext) Removeoperstmt() IRemoveoperstmtContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IRemoveoperstmtContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IRemoveoperstmtContext)
}

func (s *StmtContext) Renamestmt() IRenamestmtContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IRenamestmtContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IRenamestmtContext)
}

func (s *StmtContext) Revokestmt() IRevokestmtContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IRevokestmtContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IRevokestmtContext)
}

func (s *StmtContext) Revokerolestmt() IRevokerolestmtContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IRevokerolestmtContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IRevokerolestmtContext)
}

func (s *StmtContext) Rulestmt() IRulestmtContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IRulestmtContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IRulestmtContext)
}

func (s *StmtContext) Seclabelstmt() ISeclabelstmtContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ISeclabelstmtContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ISeclabelstmtContext)
}

func (s *StmtContext) Selectstmt() ISelectstmtContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ISelectstmtContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ISelectstmtContext)
}

func (s *StmtContext) Transactionstmt() ITransactionstmtContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ITransactionstmtContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ITransactionstmtContext)
}

func (s *StmtContext) Truncatestmt() ITruncatestmtContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ITruncatestmtContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ITruncatestmtContext)
}

func (s *StmtContext) Unlistenstmt() IUnlistenstmtContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IUnlistenstmtContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IUnlistenstmtContext)
}

func (s *StmtContext) Updatestmt() IUpdatestmtContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IUpdatestmtContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IUpdatestmtContext)
}

func (s *StmtContext) Vacuumstmt() IVacuumstmtContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IVacuumstmtContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IVacuumstmtContext)
}

func (s *StmtContext) Variableresetstmt() IVariableresetstmtContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IVariableresetstmtContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IVariableresetstmtContext)
}

func (s *StmtContext) Variablesetstmt() IVariablesetstmtContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IVariablesetstmtContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IVariablesetstmtContext)
}

func (s *StmtContext) Variableshowstmt() IVariableshowstmtContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IVariableshowstmtContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IVariableshowstmtContext)
}

func (s *StmtContext) Viewstmt() IViewstmtContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IViewstmtContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IViewstmtContext)
}

func (s *StmtContext) Plsqlconsolecommand() IPlsqlconsolecommandContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IPlsqlconsolecommandContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IPlsqlconsolecommandContext)
}

func (s *StmtContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *StmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *StmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterStmt(s)
	}
}

func (s *StmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitStmt(s)
	}
}

func (s *StmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitStmt(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Stmt() (localctx IStmtContext) {
	localctx = NewStmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 8, PostgreSQLParserRULE_stmt)
	p.SetState(1765)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(1640)
			p.Altereventtrigstmt()
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(1641)
			p.Altercollationstmt()
		}

	case 3:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(1642)
			p.Alterdatabasestmt()
		}

	case 4:
		p.EnterOuterAlt(localctx, 4)
		{
			p.SetState(1643)
			p.Alterdatabasesetstmt()
		}

	case 5:
		p.EnterOuterAlt(localctx, 5)
		{
			p.SetState(1644)
			p.Alterdefaultprivilegesstmt()
		}

	case 6:
		p.EnterOuterAlt(localctx, 6)
		{
			p.SetState(1645)
			p.Alterdomainstmt()
		}

	case 7:
		p.EnterOuterAlt(localctx, 7)
		{
			p.SetState(1646)
			p.Alterenumstmt()
		}

	case 8:
		p.EnterOuterAlt(localctx, 8)
		{
			p.SetState(1647)
			p.Alterextensionstmt()
		}

	case 9:
		p.EnterOuterAlt(localctx, 9)
		{
			p.SetState(1648)
			p.Alterextensioncontentsstmt()
		}

	case 10:
		p.EnterOuterAlt(localctx, 10)
		{
			p.SetState(1649)
			p.Alterfdwstmt()
		}

	case 11:
		p.EnterOuterAlt(localctx, 11)
		{
			p.SetState(1650)
			p.Alterforeignserverstmt()
		}

	case 12:
		p.EnterOuterAlt(localctx, 12)
		{
			p.SetState(1651)
			p.Alterfunctionstmt()
		}

	case 13:
		p.EnterOuterAlt(localctx, 13)
		{
			p.SetState(1652)
			p.Altergroupstmt()
		}

	case 14:
		p.EnterOuterAlt(localctx, 14)
		{
			p.SetState(1653)
			p.Alterobjectdependsstmt()
		}

	case 15:
		p.EnterOuterAlt(localctx, 15)
		{
			p.SetState(1654)
			p.Alterobjectschemastmt()
		}

	case 16:
		p.EnterOuterAlt(localctx, 16)
		{
			p.SetState(1655)
			p.Alterownerstmt()
		}

	case 17:
		p.EnterOuterAlt(localctx, 17)
		{
			p.SetState(1656)
			p.Alteroperatorstmt()
		}

	case 18:
		p.EnterOuterAlt(localctx, 18)
		{
			p.SetState(1657)
			p.Altertypestmt()
		}

	case 19:
		p.EnterOuterAlt(localctx, 19)
		{
			p.SetState(1658)
			p.Alterpolicystmt()
		}

	case 20:
		p.EnterOuterAlt(localctx, 20)
		{
			p.SetState(1659)
			p.Alterseqstmt()
		}

	case 21:
		p.EnterOuterAlt(localctx, 21)
		{
			p.SetState(1660)
			p.Altersystemstmt()
		}

	case 22:
		p.EnterOuterAlt(localctx, 22)
		{
			p.SetState(1661)
			p.Altertablestmt()
		}

	case 23:
		p.EnterOuterAlt(localctx, 23)
		{
			p.SetState(1662)
			p.Altertblspcstmt()
		}

	case 24:
		p.EnterOuterAlt(localctx, 24)
		{
			p.SetState(1663)
			p.Altercompositetypestmt()
		}

	case 25:
		p.EnterOuterAlt(localctx, 25)
		{
			p.SetState(1664)
			p.Alterpublicationstmt()
		}

	case 26:
		p.EnterOuterAlt(localctx, 26)
		{
			p.SetState(1665)
			p.Alterrolesetstmt()
		}

	case 27:
		p.EnterOuterAlt(localctx, 27)
		{
			p.SetState(1666)
			p.Alterrolestmt()
		}

	case 28:
		p.EnterOuterAlt(localctx, 28)
		{
			p.SetState(1667)
			p.Altersubscriptionstmt()
		}

	case 29:
		p.EnterOuterAlt(localctx, 29)
		{
			p.SetState(1668)
			p.Alterstatsstmt()
		}

	case 30:
		p.EnterOuterAlt(localctx, 30)
		{
			p.SetState(1669)
			p.Altertsconfigurationstmt()
		}

	case 31:
		p.EnterOuterAlt(localctx, 31)
		{
			p.SetState(1670)
			p.Altertsdictionarystmt()
		}

	case 32:
		p.EnterOuterAlt(localctx, 32)
		{
			p.SetState(1671)
			p.Alterusermappingstmt()
		}

	case 33:
		p.EnterOuterAlt(localctx, 33)
		{
			p.SetState(1672)
			p.Analyzestmt()
		}

	case 34:
		p.EnterOuterAlt(localctx, 34)
		{
			p.SetState(1673)
			p.Callstmt()
		}

	case 35:
		p.EnterOuterAlt(localctx, 35)
		{
			p.SetState(1674)
			p.Checkpointstmt()
		}

	case 36:
		p.EnterOuterAlt(localctx, 36)
		{
			p.SetState(1675)
			p.Closeportalstmt()
		}

	case 37:
		p.EnterOuterAlt(localctx, 37)
		{
			p.SetState(1676)
			p.Clusterstmt()
		}

	case 38:
		p.EnterOuterAlt(localctx, 38)
		{
			p.SetState(1677)
			p.Commentstmt()
		}

	case 39:
		p.EnterOuterAlt(localctx, 39)
		{
			p.SetState(1678)
			p.Constraintssetstmt()
		}

	case 40:
		p.EnterOuterAlt(localctx, 40)
		{
			p.SetState(1679)
			p.Copystmt()
		}

	case 41:
		p.EnterOuterAlt(localctx, 41)
		{
			p.SetState(1680)
			p.Createamstmt()
		}

	case 42:
		p.EnterOuterAlt(localctx, 42)
		{
			p.SetState(1681)
			p.Createasstmt()
		}

	case 43:
		p.EnterOuterAlt(localctx, 43)
		{
			p.SetState(1682)
			p.Createassertionstmt()
		}

	case 44:
		p.EnterOuterAlt(localctx, 44)
		{
			p.SetState(1683)
			p.Createcaststmt()
		}

	case 45:
		p.EnterOuterAlt(localctx, 45)
		{
			p.SetState(1684)
			p.Createconversionstmt()
		}

	case 46:
		p.EnterOuterAlt(localctx, 46)
		{
			p.SetState(1685)
			p.Createdomainstmt()
		}

	case 47:
		p.EnterOuterAlt(localctx, 47)
		{
			p.SetState(1686)
			p.Createextensionstmt()
		}

	case 48:
		p.EnterOuterAlt(localctx, 48)
		{
			p.SetState(1687)
			p.Createfdwstmt()
		}

	case 49:
		p.EnterOuterAlt(localctx, 49)
		{
			p.SetState(1688)
			p.Createforeignserverstmt()
		}

	case 50:
		p.EnterOuterAlt(localctx, 50)
		{
			p.SetState(1689)
			p.Createforeigntablestmt()
		}

	case 51:
		p.EnterOuterAlt(localctx, 51)
		{
			p.SetState(1690)
			p.Createfunctionstmt()
		}

	case 52:
		p.EnterOuterAlt(localctx, 52)
		{
			p.SetState(1691)
			p.Creategroupstmt()
		}

	case 53:
		p.EnterOuterAlt(localctx, 53)
		{
			p.SetState(1692)
			p.Creatematviewstmt()
		}

	case 54:
		p.EnterOuterAlt(localctx, 54)
		{
			p.SetState(1693)
			p.Createopclassstmt()
		}

	case 55:
		p.EnterOuterAlt(localctx, 55)
		{
			p.SetState(1694)
			p.Createopfamilystmt()
		}

	case 56:
		p.EnterOuterAlt(localctx, 56)
		{
			p.SetState(1695)
			p.Createpublicationstmt()
		}

	case 57:
		p.EnterOuterAlt(localctx, 57)
		{
			p.SetState(1696)
			p.Alteropfamilystmt()
		}

	case 58:
		p.EnterOuterAlt(localctx, 58)
		{
			p.SetState(1697)
			p.Createpolicystmt()
		}

	case 59:
		p.EnterOuterAlt(localctx, 59)
		{
			p.SetState(1698)
			p.Createplangstmt()
		}

	case 60:
		p.EnterOuterAlt(localctx, 60)
		{
			p.SetState(1699)
			p.Createschemastmt()
		}

	case 61:
		p.EnterOuterAlt(localctx, 61)
		{
			p.SetState(1700)
			p.Createseqstmt()
		}

	case 62:
		p.EnterOuterAlt(localctx, 62)
		{
			p.SetState(1701)
			p.Createstmt()
		}

	case 63:
		p.EnterOuterAlt(localctx, 63)
		{
			p.SetState(1702)
			p.Createsubscriptionstmt()
		}

	case 64:
		p.EnterOuterAlt(localctx, 64)
		{
			p.SetState(1703)
			p.Createstatsstmt()
		}

	case 65:
		p.EnterOuterAlt(localctx, 65)
		{
			p.SetState(1704)
			p.Createtablespacestmt()
		}

	case 66:
		p.EnterOuterAlt(localctx, 66)
		{
			p.SetState(1705)
			p.Createtransformstmt()
		}

	case 67:
		p.EnterOuterAlt(localctx, 67)
		{
			p.SetState(1706)
			p.Createtrigstmt()
		}

	case 68:
		p.EnterOuterAlt(localctx, 68)
		{
			p.SetState(1707)
			p.Createeventtrigstmt()
		}

	case 69:
		p.EnterOuterAlt(localctx, 69)
		{
			p.SetState(1708)
			p.Createrolestmt()
		}

	case 70:
		p.EnterOuterAlt(localctx, 70)
		{
			p.SetState(1709)
			p.Createuserstmt()
		}

	case 71:
		p.EnterOuterAlt(localctx, 71)
		{
			p.SetState(1710)
			p.Createusermappingstmt()
		}

	case 72:
		p.EnterOuterAlt(localctx, 72)
		{
			p.SetState(1711)
			p.Createdbstmt()
		}

	case 73:
		p.EnterOuterAlt(localctx, 73)
		{
			p.SetState(1712)
			p.Deallocatestmt()
		}

	case 74:
		p.EnterOuterAlt(localctx, 74)
		{
			p.SetState(1713)
			p.Declarecursorstmt()
		}

	case 75:
		p.EnterOuterAlt(localctx, 75)
		{
			p.SetState(1714)
			p.Definestmt()
		}

	case 76:
		p.EnterOuterAlt(localctx, 76)
		{
			p.SetState(1715)
			p.Deletestmt()
		}

	case 77:
		p.EnterOuterAlt(localctx, 77)
		{
			p.SetState(1716)
			p.Discardstmt()
		}

	case 78:
		p.EnterOuterAlt(localctx, 78)
		{
			p.SetState(1717)
			p.Dostmt()
		}

	case 79:
		p.EnterOuterAlt(localctx, 79)
		{
			p.SetState(1718)
			p.Dropcaststmt()
		}

	case 80:
		p.EnterOuterAlt(localctx, 80)
		{
			p.SetState(1719)
			p.Dropopclassstmt()
		}

	case 81:
		p.EnterOuterAlt(localctx, 81)
		{
			p.SetState(1720)
			p.Dropopfamilystmt()
		}

	case 82:
		p.EnterOuterAlt(localctx, 82)
		{
			p.SetState(1721)
			p.Dropownedstmt()
		}

	case 83:
		p.EnterOuterAlt(localctx, 83)
		{
			p.SetState(1722)
			p.Dropstmt()
		}

	case 84:
		p.EnterOuterAlt(localctx, 84)
		{
			p.SetState(1723)
			p.Dropsubscriptionstmt()
		}

	case 85:
		p.EnterOuterAlt(localctx, 85)
		{
			p.SetState(1724)
			p.Droptablespacestmt()
		}

	case 86:
		p.EnterOuterAlt(localctx, 86)
		{
			p.SetState(1725)
			p.Droptransformstmt()
		}

	case 87:
		p.EnterOuterAlt(localctx, 87)
		{
			p.SetState(1726)
			p.Droprolestmt()
		}

	case 88:
		p.EnterOuterAlt(localctx, 88)
		{
			p.SetState(1727)
			p.Dropusermappingstmt()
		}

	case 89:
		p.EnterOuterAlt(localctx, 89)
		{
			p.SetState(1728)
			p.Dropdbstmt()
		}

	case 90:
		p.EnterOuterAlt(localctx, 90)
		{
			p.SetState(1729)
			p.Executestmt()
		}

	case 91:
		p.EnterOuterAlt(localctx, 91)
		{
			p.SetState(1730)
			p.Explainstmt()
		}

	case 92:
		p.EnterOuterAlt(localctx, 92)
		{
			p.SetState(1731)
			p.Fetchstmt()
		}

	case 93:
		p.EnterOuterAlt(localctx, 93)
		{
			p.SetState(1732)
			p.Grantstmt()
		}

	case 94:
		p.EnterOuterAlt(localctx, 94)
		{
			p.SetState(1733)
			p.Grantrolestmt()
		}

	case 95:
		p.EnterOuterAlt(localctx, 95)
		{
			p.SetState(1734)
			p.Importforeignschemastmt()
		}

	case 96:
		p.EnterOuterAlt(localctx, 96)
		{
			p.SetState(1735)
			p.Indexstmt()
		}

	case 97:
		p.EnterOuterAlt(localctx, 97)
		{
			p.SetState(1736)
			p.Insertstmt()
		}

	case 98:
		p.EnterOuterAlt(localctx, 98)
		{
			p.SetState(1737)
			p.Mergestmt()
		}

	case 99:
		p.EnterOuterAlt(localctx, 99)
		{
			p.SetState(1738)
			p.Listenstmt()
		}

	case 100:
		p.EnterOuterAlt(localctx, 100)
		{
			p.SetState(1739)
			p.Refreshmatviewstmt()
		}

	case 101:
		p.EnterOuterAlt(localctx, 101)
		{
			p.SetState(1740)
			p.Loadstmt()
		}

	case 102:
		p.EnterOuterAlt(localctx, 102)
		{
			p.SetState(1741)
			p.Lockstmt()
		}

	case 103:
		p.EnterOuterAlt(localctx, 103)
		{
			p.SetState(1742)
			p.Notifystmt()
		}

	case 104:
		p.EnterOuterAlt(localctx, 104)
		{
			p.SetState(1743)
			p.Preparestmt()
		}

	case 105:
		p.EnterOuterAlt(localctx, 105)
		{
			p.SetState(1744)
			p.Reassignownedstmt()
		}

	case 106:
		p.EnterOuterAlt(localctx, 106)
		{
			p.SetState(1745)
			p.Reindexstmt()
		}

	case 107:
		p.EnterOuterAlt(localctx, 107)
		{
			p.SetState(1746)
			p.Removeaggrstmt()
		}

	case 108:
		p.EnterOuterAlt(localctx, 108)
		{
			p.SetState(1747)
			p.Removefuncstmt()
		}

	case 109:
		p.EnterOuterAlt(localctx, 109)
		{
			p.SetState(1748)
			p.Removeoperstmt()
		}

	case 110:
		p.EnterOuterAlt(localctx, 110)
		{
			p.SetState(1749)
			p.Renamestmt()
		}

	case 111:
		p.EnterOuterAlt(localctx, 111)
		{
			p.SetState(1750)
			p.Revokestmt()
		}

	case 112:
		p.EnterOuterAlt(localctx, 112)
		{
			p.SetState(1751)
			p.Revokerolestmt()
		}

	case 113:
		p.EnterOuterAlt(localctx, 113)
		{
			p.SetState(1752)
			p.Rulestmt()
		}

	case 114:
		p.EnterOuterAlt(localctx, 114)
		{
			p.SetState(1753)
			p.Seclabelstmt()
		}

	case 115:
		p.EnterOuterAlt(localctx, 115)
		{
			p.SetState(1754)
			p.Selectstmt()
		}

	case 116:
		p.EnterOuterAlt(localctx, 116)
		{
			p.SetState(1755)
			p.Transactionstmt()
		}

	case 117:
		p.EnterOuterAlt(localctx, 117)
		{
			p.SetState(1756)
			p.Truncatestmt()
		}

	case 118:
		p.EnterOuterAlt(localctx, 118)
		{
			p.SetState(1757)
			p.Unlistenstmt()
		}

	case 119:
		p.EnterOuterAlt(localctx, 119)
		{
			p.SetState(1758)
			p.Updatestmt()
		}

	case 120:
		p.EnterOuterAlt(localctx, 120)
		{
			p.SetState(1759)
			p.Vacuumstmt()
		}

	case 121:
		p.EnterOuterAlt(localctx, 121)
		{
			p.SetState(1760)
			p.Variableresetstmt()
		}

	case 122:
		p.EnterOuterAlt(localctx, 122)
		{
			p.SetState(1761)
			p.Variablesetstmt()
		}

	case 123:
		p.EnterOuterAlt(localctx, 123)
		{
			p.SetState(1762)
			p.Variableshowstmt()
		}

	case 124:
		p.EnterOuterAlt(localctx, 124)
		{
			p.SetState(1763)
			p.Viewstmt()
		}

	case 125:
		p.EnterOuterAlt(localctx, 125)
		{
			p.SetState(1764)
			p.Plsqlconsolecommand()
		}

	case antlr.ATNInvalidAltNumber:
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IPlsqlconsolecommandContext is an interface to support dynamic dispatch.
type IPlsqlconsolecommandContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	MetaCommand() antlr.TerminalNode
	EndMetaCommand() antlr.TerminalNode

	// IsPlsqlconsolecommandContext differentiates from other interfaces.
	IsPlsqlconsolecommandContext()
}

type PlsqlconsolecommandContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyPlsqlconsolecommandContext() *PlsqlconsolecommandContext {
	var p = new(PlsqlconsolecommandContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_plsqlconsolecommand
	return p
}

func InitEmptyPlsqlconsolecommandContext(p *PlsqlconsolecommandContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_plsqlconsolecommand
}

func (*PlsqlconsolecommandContext) IsPlsqlconsolecommandContext() {}

func NewPlsqlconsolecommandContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *PlsqlconsolecommandContext {
	var p = new(PlsqlconsolecommandContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_plsqlconsolecommand

	return p
}

func (s *PlsqlconsolecommandContext) GetParser() antlr.Parser { return s.parser }

func (s *PlsqlconsolecommandContext) MetaCommand() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserMetaCommand, 0)
}

func (s *PlsqlconsolecommandContext) EndMetaCommand() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserEndMetaCommand, 0)
}

func (s *PlsqlconsolecommandContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *PlsqlconsolecommandContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *PlsqlconsolecommandContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterPlsqlconsolecommand(s)
	}
}

func (s *PlsqlconsolecommandContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitPlsqlconsolecommand(s)
	}
}

func (s *PlsqlconsolecommandContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitPlsqlconsolecommand(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Plsqlconsolecommand() (localctx IPlsqlconsolecommandContext) {
	localctx = NewPlsqlconsolecommandContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 10, PostgreSQLParserRULE_plsqlconsolecommand)
	var _la int

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1767)
		p.Match(PostgreSQLParserMetaCommand)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	p.SetState(1769)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}
	_la = p.GetTokenStream().LA(1)

	if _la == PostgreSQLParserEndMetaCommand {
		{
			p.SetState(1768)
			p.Match(PostgreSQLParserEndMetaCommand)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// ICallstmtContext is an interface to support dynamic dispatch.
type ICallstmtContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	CALL() antlr.TerminalNode
	Func_application() IFunc_applicationContext

	// IsCallstmtContext differentiates from other interfaces.
	IsCallstmtContext()
}

type CallstmtContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyCallstmtContext() *CallstmtContext {
	var p = new(CallstmtContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_callstmt
	return p
}

func InitEmptyCallstmtContext(p *CallstmtContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_callstmt
}

func (*CallstmtContext) IsCallstmtContext() {}

func NewCallstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CallstmtContext {
	var p = new(CallstmtContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_callstmt

	return p
}

func (s *CallstmtContext) GetParser() antlr.Parser { return s.parser }

func (s *CallstmtContext) CALL() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCALL, 0)
}

func (s *CallstmtContext) Func_application() IFunc_applicationContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IFunc_applicationContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IFunc_applicationContext)
}

func (s *CallstmtContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *CallstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *CallstmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterCallstmt(s)
	}
}

func (s *CallstmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitCallstmt(s)
	}
}

func (s *CallstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitCallstmt(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Callstmt() (localctx ICallstmtContext) {
	localctx = NewCallstmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 12, PostgreSQLParserRULE_callstmt)
	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1771)
		p.Match(PostgreSQLParserCALL)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(1772)
		p.Func_application()
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// ICreaterolestmtContext is an interface to support dynamic dispatch.
type ICreaterolestmtContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	CREATE() antlr.TerminalNode
	ROLE() antlr.TerminalNode
	Roleid() IRoleidContext
	Opt_with() IOpt_withContext
	Optrolelist() IOptrolelistContext

	// IsCreaterolestmtContext differentiates from other interfaces.
	IsCreaterolestmtContext()
}

type CreaterolestmtContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyCreaterolestmtContext() *CreaterolestmtContext {
	var p = new(CreaterolestmtContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_createrolestmt
	return p
}

func InitEmptyCreaterolestmtContext(p *CreaterolestmtContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_createrolestmt
}

func (*CreaterolestmtContext) IsCreaterolestmtContext() {}

func NewCreaterolestmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CreaterolestmtContext {
	var p = new(CreaterolestmtContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_createrolestmt

	return p
}

func (s *CreaterolestmtContext) GetParser() antlr.Parser { return s.parser }

func (s *CreaterolestmtContext) CREATE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCREATE, 0)
}

func (s *CreaterolestmtContext) ROLE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserROLE, 0)
}

func (s *CreaterolestmtContext) Roleid() IRoleidContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IRoleidContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IRoleidContext)
}

func (s *CreaterolestmtContext) Opt_with() IOpt_withContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOpt_withContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOpt_withContext)
}

func (s *CreaterolestmtContext) Optrolelist() IOptrolelistContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOptrolelistContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOptrolelistContext)
}

func (s *CreaterolestmtContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *CreaterolestmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *CreaterolestmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterCreaterolestmt(s)
	}
}

func (s *CreaterolestmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitCreaterolestmt(s)
	}
}

func (s *CreaterolestmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitCreaterolestmt(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Createrolestmt() (localctx ICreaterolestmtContext) {
	localctx = NewCreaterolestmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 14, PostgreSQLParserRULE_createrolestmt)
	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1774)
		p.Match(PostgreSQLParserCREATE)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(1775)
		p.Match(PostgreSQLParserROLE)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(1776)
		p.Roleid()
	}
	{
		p.SetState(1777)
		p.Opt_with()
	}
	{
		p.SetState(1778)
		p.Optrolelist()
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IOpt_withContext is an interface to support dynamic dispatch.
type IOpt_withContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	WITH() antlr.TerminalNode

	// IsOpt_withContext differentiates from other interfaces.
	IsOpt_withContext()
}

type Opt_withContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyOpt_withContext() *Opt_withContext {
	var p = new(Opt_withContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opt_with
	return p
}

func InitEmptyOpt_withContext(p *Opt_withContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opt_with
}

func (*Opt_withContext) IsOpt_withContext() {}

func NewOpt_withContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_withContext {
	var p = new(Opt_withContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_opt_with

	return p
}

func (s *Opt_withContext) GetParser() antlr.Parser { return s.parser }

func (s *Opt_withContext) WITH() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserWITH, 0)
}

func (s *Opt_withContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Opt_withContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Opt_withContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterOpt_with(s)
	}
}

func (s *Opt_withContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitOpt_with(s)
	}
}

func (s *Opt_withContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitOpt_with(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Opt_with() (localctx IOpt_withContext) {
	localctx = NewOpt_withContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 16, PostgreSQLParserRULE_opt_with)
	p.SetState(1782)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 4, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(1780)
			p.Match(PostgreSQLParserWITH)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)

	case antlr.ATNInvalidAltNumber:
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IOptrolelistContext is an interface to support dynamic dispatch.
type IOptrolelistContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	AllCreateoptroleelem() []ICreateoptroleelemContext
	Createoptroleelem(i int) ICreateoptroleelemContext

	// IsOptrolelistContext differentiates from other interfaces.
	IsOptrolelistContext()
}

type OptrolelistContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyOptrolelistContext() *OptrolelistContext {
	var p = new(OptrolelistContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_optrolelist
	return p
}

func InitEmptyOptrolelistContext(p *OptrolelistContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_optrolelist
}

func (*OptrolelistContext) IsOptrolelistContext() {}

func NewOptrolelistContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *OptrolelistContext {
	var p = new(OptrolelistContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_optrolelist

	return p
}

func (s *OptrolelistContext) GetParser() antlr.Parser { return s.parser }

func (s *OptrolelistContext) AllCreateoptroleelem() []ICreateoptroleelemContext {
	children := s.GetChildren()
	len := 0
	for _, ctx := range children {
		if _, ok := ctx.(ICreateoptroleelemContext); ok {
			len++
		}
	}

	tst := make([]ICreateoptroleelemContext, len)
	i := 0
	for _, ctx := range children {
		if t, ok := ctx.(ICreateoptroleelemContext); ok {
			tst[i] = t.(ICreateoptroleelemContext)
			i++
		}
	}

	return tst
}

func (s *OptrolelistContext) Createoptroleelem(i int) ICreateoptroleelemContext {
	var t antlr.RuleContext
	j := 0
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ICreateoptroleelemContext); ok {
			if j == i {
				t = ctx.(antlr.RuleContext)
				break
			}
			j++
		}
	}

	if t == nil {
		return nil
	}

	return t.(ICreateoptroleelemContext)
}

func (s *OptrolelistContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *OptrolelistContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *OptrolelistContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterOptrolelist(s)
	}
}

func (s *OptrolelistContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitOptrolelist(s)
	}
}

func (s *OptrolelistContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitOptrolelist(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Optrolelist() (localctx IOptrolelistContext) {
	localctx = NewOptrolelistContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 18, PostgreSQLParserRULE_optrolelist)
	var _alt int

	p.EnterOuterAlt(localctx, 1)
	p.SetState(1787)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}
	_alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 5, p.GetParserRuleContext())
	if p.HasError() {
		goto errorExit
	}
	for _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
		if _alt == 1 {
			{
				p.SetState(1784)
				p.Createoptroleelem()
			}

		}
		p.SetState(1789)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}
		_alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 5, p.GetParserRuleContext())
		if p.HasError() {
			goto errorExit
		}
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IAlteroptrolelistContext is an interface to support dynamic dispatch.
type IAlteroptrolelistContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	AllAlteroptroleelem() []IAlteroptroleelemContext
	Alteroptroleelem(i int) IAlteroptroleelemContext

	// IsAlteroptrolelistContext differentiates from other interfaces.
	IsAlteroptrolelistContext()
}

type AlteroptrolelistContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyAlteroptrolelistContext() *AlteroptrolelistContext {
	var p = new(AlteroptrolelistContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_alteroptrolelist
	return p
}

func InitEmptyAlteroptrolelistContext(p *AlteroptrolelistContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_alteroptrolelist
}

func (*AlteroptrolelistContext) IsAlteroptrolelistContext() {}

func NewAlteroptrolelistContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AlteroptrolelistContext {
	var p = new(AlteroptrolelistContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_alteroptrolelist

	return p
}

func (s *AlteroptrolelistContext) GetParser() antlr.Parser { return s.parser }

func (s *AlteroptrolelistContext) AllAlteroptroleelem() []IAlteroptroleelemContext {
	children := s.GetChildren()
	len := 0
	for _, ctx := range children {
		if _, ok := ctx.(IAlteroptroleelemContext); ok {
			len++
		}
	}

	tst := make([]IAlteroptroleelemContext, len)
	i := 0
	for _, ctx := range children {
		if t, ok := ctx.(IAlteroptroleelemContext); ok {
			tst[i] = t.(IAlteroptroleelemContext)
			i++
		}
	}

	return tst
}

func (s *AlteroptrolelistContext) Alteroptroleelem(i int) IAlteroptroleelemContext {
	var t antlr.RuleContext
	j := 0
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IAlteroptroleelemContext); ok {
			if j == i {
				t = ctx.(antlr.RuleContext)
				break
			}
			j++
		}
	}

	if t == nil {
		return nil
	}

	return t.(IAlteroptroleelemContext)
}

func (s *AlteroptrolelistContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *AlteroptrolelistContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *AlteroptrolelistContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterAlteroptrolelist(s)
	}
}

func (s *AlteroptrolelistContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitAlteroptrolelist(s)
	}
}

func (s *AlteroptrolelistContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitAlteroptrolelist(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Alteroptrolelist() (localctx IAlteroptrolelistContext) {
	localctx = NewAlteroptrolelistContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 20, PostgreSQLParserRULE_alteroptrolelist)
	var _alt int

	p.EnterOuterAlt(localctx, 1)
	p.SetState(1793)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}
	_alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 6, p.GetParserRuleContext())
	if p.HasError() {
		goto errorExit
	}
	for _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
		if _alt == 1 {
			{
				p.SetState(1790)
				p.Alteroptroleelem()
			}

		}
		p.SetState(1795)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}
		_alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 6, p.GetParserRuleContext())
		if p.HasError() {
			goto errorExit
		}
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IAlteroptroleelemContext is an interface to support dynamic dispatch.
type IAlteroptroleelemContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	PASSWORD() antlr.TerminalNode
	Sconst() ISconstContext
	NULL_P() antlr.TerminalNode
	ENCRYPTED() antlr.TerminalNode
	UNENCRYPTED() antlr.TerminalNode
	INHERIT() antlr.TerminalNode
	CONNECTION() antlr.TerminalNode
	LIMIT() antlr.TerminalNode
	Signediconst() ISignediconstContext
	VALID() antlr.TerminalNode
	UNTIL() antlr.TerminalNode
	USER() antlr.TerminalNode
	Role_list() IRole_listContext
	Identifier() IIdentifierContext

	// IsAlteroptroleelemContext differentiates from other interfaces.
	IsAlteroptroleelemContext()
}

type AlteroptroleelemContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyAlteroptroleelemContext() *AlteroptroleelemContext {
	var p = new(AlteroptroleelemContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_alteroptroleelem
	return p
}

func InitEmptyAlteroptroleelemContext(p *AlteroptroleelemContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_alteroptroleelem
}

func (*AlteroptroleelemContext) IsAlteroptroleelemContext() {}

func NewAlteroptroleelemContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AlteroptroleelemContext {
	var p = new(AlteroptroleelemContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_alteroptroleelem

	return p
}

func (s *AlteroptroleelemContext) GetParser() antlr.Parser { return s.parser }

func (s *AlteroptroleelemContext) PASSWORD() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserPASSWORD, 0)
}

func (s *AlteroptroleelemContext) Sconst() ISconstContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ISconstContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ISconstContext)
}

func (s *AlteroptroleelemContext) NULL_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserNULL_P, 0)
}

func (s *AlteroptroleelemContext) ENCRYPTED() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserENCRYPTED, 0)
}

func (s *AlteroptroleelemContext) UNENCRYPTED() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserUNENCRYPTED, 0)
}

func (s *AlteroptroleelemContext) INHERIT() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserINHERIT, 0)
}

func (s *AlteroptroleelemContext) CONNECTION() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCONNECTION, 0)
}

func (s *AlteroptroleelemContext) LIMIT() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserLIMIT, 0)
}

func (s *AlteroptroleelemContext) Signediconst() ISignediconstContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ISignediconstContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ISignediconstContext)
}

func (s *AlteroptroleelemContext) VALID() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserVALID, 0)
}

func (s *AlteroptroleelemContext) UNTIL() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserUNTIL, 0)
}

func (s *AlteroptroleelemContext) USER() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserUSER, 0)
}

func (s *AlteroptroleelemContext) Role_list() IRole_listContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IRole_listContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IRole_listContext)
}

func (s *AlteroptroleelemContext) Identifier() IIdentifierContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IIdentifierContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IIdentifierContext)
}

func (s *AlteroptroleelemContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *AlteroptroleelemContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *AlteroptroleelemContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterAlteroptroleelem(s)
	}
}

func (s *AlteroptroleelemContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitAlteroptroleelem(s)
	}
}

func (s *AlteroptroleelemContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitAlteroptroleelem(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Alteroptroleelem() (localctx IAlteroptroleelemContext) {
	localctx = NewAlteroptroleelemContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 22, PostgreSQLParserRULE_alteroptroleelem)
	var _la int

	p.SetState(1814)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetTokenStream().LA(1) {
	case PostgreSQLParserPASSWORD:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(1796)
			p.Match(PostgreSQLParserPASSWORD)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		p.SetState(1799)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}

		switch p.GetTokenStream().LA(1) {
		case PostgreSQLParserStringConstant, PostgreSQLParserUnicodeEscapeStringConstant, PostgreSQLParserBeginDollarStringConstant, PostgreSQLParserEscapeStringConstant:
			{
				p.SetState(1797)
				p.Sconst()
			}

		case PostgreSQLParserNULL_P:
			{
				p.SetState(1798)
				p.Match(PostgreSQLParserNULL_P)
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}

		default:
			p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
			goto errorExit
		}

	case PostgreSQLParserENCRYPTED, PostgreSQLParserUNENCRYPTED:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(1801)
			_la = p.GetTokenStream().LA(1)

			if !(_la == PostgreSQLParserENCRYPTED || _la == PostgreSQLParserUNENCRYPTED) {
				p.GetErrorHandler().RecoverInline(p)
			} else {
				p.GetErrorHandler().ReportMatch(p)
				p.Consume()
			}
		}
		{
			p.SetState(1802)
			p.Match(PostgreSQLParserPASSWORD)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(1803)
			p.Sconst()
		}

	case PostgreSQLParserINHERIT:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(1804)
			p.Match(PostgreSQLParserINHERIT)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case PostgreSQLParserCONNECTION:
		p.EnterOuterAlt(localctx, 4)
		{
			p.SetState(1805)
			p.Match(PostgreSQLParserCONNECTION)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(1806)
			p.Match(PostgreSQLParserLIMIT)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(1807)
			p.Signediconst()
		}

	case PostgreSQLParserVALID:
		p.EnterOuterAlt(localctx, 5)
		{
			p.SetState(1808)
			p.Match(PostgreSQLParserVALID)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(1809)
			p.Match(PostgreSQLParserUNTIL)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(1810)
			p.Sconst()
		}

	case PostgreSQLParserUSER:
		p.EnterOuterAlt(localctx, 6)
		{
			p.SetState(1811)
			p.Match(PostgreSQLParserUSER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(1812)
			p.Role_list()
		}

	case PostgreSQLParserAND, PostgreSQLParserARRAY, PostgreSQLParserCOLLATE, PostgreSQLParserCOLUMN, PostgreSQLParserCONSTRAINT, PostgreSQLParserDEFAULT, PostgreSQLParserDO, PostgreSQLParserFETCH, PostgreSQLParserTABLE, PostgreSQLParserIS, PostgreSQLParserOUTER_P, PostgreSQLParserABSOLUTE_P, PostgreSQLParserBACKWARD, PostgreSQLParserCHAIN, PostgreSQLParserCLOSE, PostgreSQLParserCOMMIT, PostgreSQLParserCONTINUE_P, PostgreSQLParserCURSOR, PostgreSQLParserFIRST_P, PostgreSQLParserFORWARD, PostgreSQLParserINSERT, PostgreSQLParserLAST_P, PostgreSQLParserMOVE, PostgreSQLParserNEXT, PostgreSQLParserNO, PostgreSQLParserOPTION, PostgreSQLParserPRIOR, PostgreSQLParserRELATIVE_P, PostgreSQLParserRESET, PostgreSQLParserROLLBACK, PostgreSQLParserSCHEMA, PostgreSQLParserSCROLL, PostgreSQLParserSET, PostgreSQLParserTYPE_P, PostgreSQLParserCALL, PostgreSQLParserCURRENT_P, PostgreSQLParserROWTYPE, PostgreSQLParserDUMP, PostgreSQLParserPRINT_STRICT_PARAMS, PostgreSQLParserVARIABLE_CONFLICT, PostgreSQLParserERROR, PostgreSQLParserUSE_VARIABLE, PostgreSQLParserUSE_COLUMN, PostgreSQLParserALIAS, PostgreSQLParserCONSTANT, PostgreSQLParserPERFORM, PostgreSQLParserGET, PostgreSQLParserDIAGNOSTICS, PostgreSQLParserSTACKED, PostgreSQLParserELSIF, PostgreSQLParserSLICE, PostgreSQLParserEXIT, PostgreSQLParserRETURN, PostgreSQLParserQUERY, PostgreSQLParserRAISE, PostgreSQLParserSQLSTATE, PostgreSQLParserDEBUG, PostgreSQLParserINFO, PostgreSQLParserNOTICE, PostgreSQLParserWARNING, PostgreSQLParserEXCEPTION, PostgreSQLParserASSERT, PostgreSQLParserOPEN, PostgreSQLParserIdentifier, PostgreSQLParserQuotedIdentifier, PostgreSQLParserUnicodeQuotedIdentifier, PostgreSQLParserPLSQLVARIABLENAME, PostgreSQLParserPLSQLIDENTIFIER:
		p.EnterOuterAlt(localctx, 7)
		{
			p.SetState(1813)
			p.Identifier()
		}

	default:
		p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// ICreateoptroleelemContext is an interface to support dynamic dispatch.
type ICreateoptroleelemContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Alteroptroleelem() IAlteroptroleelemContext
	SYSID() antlr.TerminalNode
	Iconst() IIconstContext
	ADMIN() antlr.TerminalNode
	Role_list() IRole_listContext
	ROLE() antlr.TerminalNode
	IN_P() antlr.TerminalNode
	GROUP_P() antlr.TerminalNode

	// IsCreateoptroleelemContext differentiates from other interfaces.
	IsCreateoptroleelemContext()
}

type CreateoptroleelemContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyCreateoptroleelemContext() *CreateoptroleelemContext {
	var p = new(CreateoptroleelemContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_createoptroleelem
	return p
}

func InitEmptyCreateoptroleelemContext(p *CreateoptroleelemContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_createoptroleelem
}

func (*CreateoptroleelemContext) IsCreateoptroleelemContext() {}

func NewCreateoptroleelemContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CreateoptroleelemContext {
	var p = new(CreateoptroleelemContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_createoptroleelem

	return p
}

func (s *CreateoptroleelemContext) GetParser() antlr.Parser { return s.parser }

func (s *CreateoptroleelemContext) Alteroptroleelem() IAlteroptroleelemContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IAlteroptroleelemContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IAlteroptroleelemContext)
}

func (s *CreateoptroleelemContext) SYSID() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserSYSID, 0)
}

func (s *CreateoptroleelemContext) Iconst() IIconstContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IIconstContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IIconstContext)
}

func (s *CreateoptroleelemContext) ADMIN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserADMIN, 0)
}

func (s *CreateoptroleelemContext) Role_list() IRole_listContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IRole_listContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IRole_listContext)
}

func (s *CreateoptroleelemContext) ROLE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserROLE, 0)
}

func (s *CreateoptroleelemContext) IN_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserIN_P, 0)
}

func (s *CreateoptroleelemContext) GROUP_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserGROUP_P, 0)
}

func (s *CreateoptroleelemContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *CreateoptroleelemContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *CreateoptroleelemContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterCreateoptroleelem(s)
	}
}

func (s *CreateoptroleelemContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitCreateoptroleelem(s)
	}
}

func (s *CreateoptroleelemContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitCreateoptroleelem(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Createoptroleelem() (localctx ICreateoptroleelemContext) {
	localctx = NewCreateoptroleelemContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 24, PostgreSQLParserRULE_createoptroleelem)
	var _la int

	p.SetState(1826)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetTokenStream().LA(1) {
	case PostgreSQLParserAND, PostgreSQLParserARRAY, PostgreSQLParserCOLLATE, PostgreSQLParserCOLUMN, PostgreSQLParserCONSTRAINT, PostgreSQLParserDEFAULT, PostgreSQLParserDO, PostgreSQLParserFETCH, PostgreSQLParserTABLE, PostgreSQLParserUSER, PostgreSQLParserIS, PostgreSQLParserOUTER_P, PostgreSQLParserABSOLUTE_P, PostgreSQLParserBACKWARD, PostgreSQLParserCHAIN, PostgreSQLParserCLOSE, PostgreSQLParserCOMMIT, PostgreSQLParserCONNECTION, PostgreSQLParserCONTINUE_P, PostgreSQLParserCURSOR, PostgreSQLParserENCRYPTED, PostgreSQLParserFIRST_P, PostgreSQLParserFORWARD, PostgreSQLParserINHERIT, PostgreSQLParserINSERT, PostgreSQLParserLAST_P, PostgreSQLParserMOVE, PostgreSQLParserNEXT, PostgreSQLParserNO, PostgreSQLParserOPTION, PostgreSQLParserPASSWORD, PostgreSQLParserPRIOR, PostgreSQLParserRELATIVE_P, PostgreSQLParserRESET, PostgreSQLParserROLLBACK, PostgreSQLParserSCHEMA, PostgreSQLParserSCROLL, PostgreSQLParserSET, PostgreSQLParserTYPE_P, PostgreSQLParserUNENCRYPTED, PostgreSQLParserVALID, PostgreSQLParserCALL, PostgreSQLParserCURRENT_P, PostgreSQLParserROWTYPE, PostgreSQLParserDUMP, PostgreSQLParserPRINT_STRICT_PARAMS, PostgreSQLParserVARIABLE_CONFLICT, PostgreSQLParserERROR, PostgreSQLParserUSE_VARIABLE, PostgreSQLParserUSE_COLUMN, PostgreSQLParserALIAS, PostgreSQLParserCONSTANT, PostgreSQLParserPERFORM, PostgreSQLParserGET, PostgreSQLParserDIAGNOSTICS, PostgreSQLParserSTACKED, PostgreSQLParserELSIF, PostgreSQLParserSLICE, PostgreSQLParserEXIT, PostgreSQLParserRETURN, PostgreSQLParserQUERY, PostgreSQLParserRAISE, PostgreSQLParserSQLSTATE, PostgreSQLParserDEBUG, PostgreSQLParserINFO, PostgreSQLParserNOTICE, PostgreSQLParserWARNING, PostgreSQLParserEXCEPTION, PostgreSQLParserASSERT, PostgreSQLParserOPEN, PostgreSQLParserIdentifier, PostgreSQLParserQuotedIdentifier, PostgreSQLParserUnicodeQuotedIdentifier, PostgreSQLParserPLSQLVARIABLENAME, PostgreSQLParserPLSQLIDENTIFIER:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(1816)
			p.Alteroptroleelem()
		}

	case PostgreSQLParserSYSID:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(1817)
			p.Match(PostgreSQLParserSYSID)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(1818)
			p.Iconst()
		}

	case PostgreSQLParserADMIN:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(1819)
			p.Match(PostgreSQLParserADMIN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(1820)
			p.Role_list()
		}

	case PostgreSQLParserROLE:
		p.EnterOuterAlt(localctx, 4)
		{
			p.SetState(1821)
			p.Match(PostgreSQLParserROLE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(1822)
			p.Role_list()
		}

	case PostgreSQLParserIN_P:
		p.EnterOuterAlt(localctx, 5)
		{
			p.SetState(1823)
			p.Match(PostgreSQLParserIN_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(1824)
			_la = p.GetTokenStream().LA(1)

			if !(_la == PostgreSQLParserGROUP_P || _la == PostgreSQLParserROLE) {
				p.GetErrorHandler().RecoverInline(p)
			} else {
				p.GetErrorHandler().ReportMatch(p)
				p.Consume()
			}
		}
		{
			p.SetState(1825)
			p.Role_list()
		}

	default:
		p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// ICreateuserstmtContext is an interface to support dynamic dispatch.
type ICreateuserstmtContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	CREATE() antlr.TerminalNode
	USER() antlr.TerminalNode
	Roleid() IRoleidContext
	Opt_with() IOpt_withContext
	Optrolelist() IOptrolelistContext

	// IsCreateuserstmtContext differentiates from other interfaces.
	IsCreateuserstmtContext()
}

type CreateuserstmtContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyCreateuserstmtContext() *CreateuserstmtContext {
	var p = new(CreateuserstmtContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_createuserstmt
	return p
}

func InitEmptyCreateuserstmtContext(p *CreateuserstmtContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_createuserstmt
}

func (*CreateuserstmtContext) IsCreateuserstmtContext() {}

func NewCreateuserstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CreateuserstmtContext {
	var p = new(CreateuserstmtContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_createuserstmt

	return p
}

func (s *CreateuserstmtContext) GetParser() antlr.Parser { return s.parser }

func (s *CreateuserstmtContext) CREATE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCREATE, 0)
}

func (s *CreateuserstmtContext) USER() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserUSER, 0)
}

func (s *CreateuserstmtContext) Roleid() IRoleidContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IRoleidContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IRoleidContext)
}

func (s *CreateuserstmtContext) Opt_with() IOpt_withContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOpt_withContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOpt_withContext)
}

func (s *CreateuserstmtContext) Optrolelist() IOptrolelistContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOptrolelistContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOptrolelistContext)
}

func (s *CreateuserstmtContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *CreateuserstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *CreateuserstmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterCreateuserstmt(s)
	}
}

func (s *CreateuserstmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitCreateuserstmt(s)
	}
}

func (s *CreateuserstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitCreateuserstmt(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Createuserstmt() (localctx ICreateuserstmtContext) {
	localctx = NewCreateuserstmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 26, PostgreSQLParserRULE_createuserstmt)
	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1828)
		p.Match(PostgreSQLParserCREATE)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(1829)
		p.Match(PostgreSQLParserUSER)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(1830)
		p.Roleid()
	}
	{
		p.SetState(1831)
		p.Opt_with()
	}
	{
		p.SetState(1832)
		p.Optrolelist()
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IAlterrolestmtContext is an interface to support dynamic dispatch.
type IAlterrolestmtContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	ALTER() antlr.TerminalNode
	Rolespec() IRolespecContext
	Opt_with() IOpt_withContext
	Alteroptrolelist() IAlteroptrolelistContext
	ROLE() antlr.TerminalNode
	USER() antlr.TerminalNode

	// IsAlterrolestmtContext differentiates from other interfaces.
	IsAlterrolestmtContext()
}

type AlterrolestmtContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyAlterrolestmtContext() *AlterrolestmtContext {
	var p = new(AlterrolestmtContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_alterrolestmt
	return p
}

func InitEmptyAlterrolestmtContext(p *AlterrolestmtContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_alterrolestmt
}

func (*AlterrolestmtContext) IsAlterrolestmtContext() {}

func NewAlterrolestmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AlterrolestmtContext {
	var p = new(AlterrolestmtContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_alterrolestmt

	return p
}

func (s *AlterrolestmtContext) GetParser() antlr.Parser { return s.parser }

func (s *AlterrolestmtContext) ALTER() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserALTER, 0)
}

func (s *AlterrolestmtContext) Rolespec() IRolespecContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IRolespecContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IRolespecContext)
}

func (s *AlterrolestmtContext) Opt_with() IOpt_withContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOpt_withContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOpt_withContext)
}

func (s *AlterrolestmtContext) Alteroptrolelist() IAlteroptrolelistContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IAlteroptrolelistContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IAlteroptrolelistContext)
}

func (s *AlterrolestmtContext) ROLE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserROLE, 0)
}

func (s *AlterrolestmtContext) USER() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserUSER, 0)
}

func (s *AlterrolestmtContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *AlterrolestmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *AlterrolestmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterAlterrolestmt(s)
	}
}

func (s *AlterrolestmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitAlterrolestmt(s)
	}
}

func (s *AlterrolestmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitAlterrolestmt(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Alterrolestmt() (localctx IAlterrolestmtContext) {
	localctx = NewAlterrolestmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 28, PostgreSQLParserRULE_alterrolestmt)
	var _la int

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1834)
		p.Match(PostgreSQLParserALTER)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(1835)
		_la = p.GetTokenStream().LA(1)

		if !(_la == PostgreSQLParserUSER || _la == PostgreSQLParserROLE) {
			p.GetErrorHandler().RecoverInline(p)
		} else {
			p.GetErrorHandler().ReportMatch(p)
			p.Consume()
		}
	}
	{
		p.SetState(1836)
		p.Rolespec()
	}
	{
		p.SetState(1837)
		p.Opt_with()
	}
	{
		p.SetState(1838)
		p.Alteroptrolelist()
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IOpt_in_databaseContext is an interface to support dynamic dispatch.
type IOpt_in_databaseContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	IN_P() antlr.TerminalNode
	DATABASE() antlr.TerminalNode
	Name() INameContext

	// IsOpt_in_databaseContext differentiates from other interfaces.
	IsOpt_in_databaseContext()
}

type Opt_in_databaseContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyOpt_in_databaseContext() *Opt_in_databaseContext {
	var p = new(Opt_in_databaseContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opt_in_database
	return p
}

func InitEmptyOpt_in_databaseContext(p *Opt_in_databaseContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opt_in_database
}

func (*Opt_in_databaseContext) IsOpt_in_databaseContext() {}

func NewOpt_in_databaseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_in_databaseContext {
	var p = new(Opt_in_databaseContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_opt_in_database

	return p
}

func (s *Opt_in_databaseContext) GetParser() antlr.Parser { return s.parser }

func (s *Opt_in_databaseContext) IN_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserIN_P, 0)
}

func (s *Opt_in_databaseContext) DATABASE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserDATABASE, 0)
}

func (s *Opt_in_databaseContext) Name() INameContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(INameContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(INameContext)
}

func (s *Opt_in_databaseContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Opt_in_databaseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Opt_in_databaseContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterOpt_in_database(s)
	}
}

func (s *Opt_in_databaseContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitOpt_in_database(s)
	}
}

func (s *Opt_in_databaseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitOpt_in_database(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Opt_in_database() (localctx IOpt_in_databaseContext) {
	localctx = NewOpt_in_databaseContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 30, PostgreSQLParserRULE_opt_in_database)
	p.SetState(1844)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetTokenStream().LA(1) {
	case PostgreSQLParserRESET, PostgreSQLParserSET:
		p.EnterOuterAlt(localctx, 1)

	case PostgreSQLParserIN_P:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(1841)
			p.Match(PostgreSQLParserIN_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(1842)
			p.Match(PostgreSQLParserDATABASE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(1843)
			p.Name()
		}

	default:
		p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IAlterrolesetstmtContext is an interface to support dynamic dispatch.
type IAlterrolesetstmtContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	ALTER() antlr.TerminalNode
	Rolespec() IRolespecContext
	Opt_in_database() IOpt_in_databaseContext
	Setresetclause() ISetresetclauseContext
	ROLE() antlr.TerminalNode
	USER() antlr.TerminalNode
	ALL() antlr.TerminalNode

	// IsAlterrolesetstmtContext differentiates from other interfaces.
	IsAlterrolesetstmtContext()
}

type AlterrolesetstmtContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyAlterrolesetstmtContext() *AlterrolesetstmtContext {
	var p = new(AlterrolesetstmtContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_alterrolesetstmt
	return p
}

func InitEmptyAlterrolesetstmtContext(p *AlterrolesetstmtContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_alterrolesetstmt
}

func (*AlterrolesetstmtContext) IsAlterrolesetstmtContext() {}

func NewAlterrolesetstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AlterrolesetstmtContext {
	var p = new(AlterrolesetstmtContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_alterrolesetstmt

	return p
}

func (s *AlterrolesetstmtContext) GetParser() antlr.Parser { return s.parser }

func (s *AlterrolesetstmtContext) ALTER() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserALTER, 0)
}

func (s *AlterrolesetstmtContext) Rolespec() IRolespecContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IRolespecContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IRolespecContext)
}

func (s *AlterrolesetstmtContext) Opt_in_database() IOpt_in_databaseContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOpt_in_databaseContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOpt_in_databaseContext)
}

func (s *AlterrolesetstmtContext) Setresetclause() ISetresetclauseContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ISetresetclauseContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ISetresetclauseContext)
}

func (s *AlterrolesetstmtContext) ROLE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserROLE, 0)
}

func (s *AlterrolesetstmtContext) USER() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserUSER, 0)
}

func (s *AlterrolesetstmtContext) ALL() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserALL, 0)
}

func (s *AlterrolesetstmtContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *AlterrolesetstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *AlterrolesetstmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterAlterrolesetstmt(s)
	}
}

func (s *AlterrolesetstmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitAlterrolesetstmt(s)
	}
}

func (s *AlterrolesetstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitAlterrolesetstmt(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Alterrolesetstmt() (localctx IAlterrolesetstmtContext) {
	localctx = NewAlterrolesetstmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 32, PostgreSQLParserRULE_alterrolesetstmt)
	var _la int

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1846)
		p.Match(PostgreSQLParserALTER)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(1847)
		_la = p.GetTokenStream().LA(1)

		if !(_la == PostgreSQLParserUSER || _la == PostgreSQLParserROLE) {
			p.GetErrorHandler().RecoverInline(p)
		} else {
			p.GetErrorHandler().ReportMatch(p)
			p.Consume()
		}
	}
	p.SetState(1849)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}
	_la = p.GetTokenStream().LA(1)

	if _la == PostgreSQLParserALL {
		{
			p.SetState(1848)
			p.Match(PostgreSQLParserALL)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	}
	{
		p.SetState(1851)
		p.Rolespec()
	}
	{
		p.SetState(1852)
		p.Opt_in_database()
	}
	{
		p.SetState(1853)
		p.Setresetclause()
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IDroprolestmtContext is an interface to support dynamic dispatch.
type IDroprolestmtContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	DROP() antlr.TerminalNode
	Role_list() IRole_listContext
	ROLE() antlr.TerminalNode
	USER() antlr.TerminalNode
	GROUP_P() antlr.TerminalNode
	IF_P() antlr.TerminalNode
	EXISTS() antlr.TerminalNode

	// IsDroprolestmtContext differentiates from other interfaces.
	IsDroprolestmtContext()
}

type DroprolestmtContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyDroprolestmtContext() *DroprolestmtContext {
	var p = new(DroprolestmtContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_droprolestmt
	return p
}

func InitEmptyDroprolestmtContext(p *DroprolestmtContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_droprolestmt
}

func (*DroprolestmtContext) IsDroprolestmtContext() {}

func NewDroprolestmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DroprolestmtContext {
	var p = new(DroprolestmtContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_droprolestmt

	return p
}

func (s *DroprolestmtContext) GetParser() antlr.Parser { return s.parser }

func (s *DroprolestmtContext) DROP() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserDROP, 0)
}

func (s *DroprolestmtContext) Role_list() IRole_listContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IRole_listContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IRole_listContext)
}

func (s *DroprolestmtContext) ROLE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserROLE, 0)
}

func (s *DroprolestmtContext) USER() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserUSER, 0)
}

func (s *DroprolestmtContext) GROUP_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserGROUP_P, 0)
}

func (s *DroprolestmtContext) IF_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserIF_P, 0)
}

func (s *DroprolestmtContext) EXISTS() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserEXISTS, 0)
}

func (s *DroprolestmtContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *DroprolestmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *DroprolestmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterDroprolestmt(s)
	}
}

func (s *DroprolestmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitDroprolestmt(s)
	}
}

func (s *DroprolestmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitDroprolestmt(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Droprolestmt() (localctx IDroprolestmtContext) {
	localctx = NewDroprolestmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 34, PostgreSQLParserRULE_droprolestmt)
	var _la int

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1855)
		p.Match(PostgreSQLParserDROP)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(1856)
		_la = p.GetTokenStream().LA(1)

		if !(_la == PostgreSQLParserGROUP_P || _la == PostgreSQLParserUSER || _la == PostgreSQLParserROLE) {
			p.GetErrorHandler().RecoverInline(p)
		} else {
			p.GetErrorHandler().ReportMatch(p)
			p.Consume()
		}
	}
	p.SetState(1859)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 12, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(1857)
			p.Match(PostgreSQLParserIF_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(1858)
			p.Match(PostgreSQLParserEXISTS)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	} else if p.HasError() { // JIM
		goto errorExit
	}
	{
		p.SetState(1861)
		p.Role_list()
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// ICreategroupstmtContext is an interface to support dynamic dispatch.
type ICreategroupstmtContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	CREATE() antlr.TerminalNode
	GROUP_P() antlr.TerminalNode
	Roleid() IRoleidContext
	Opt_with() IOpt_withContext
	Optrolelist() IOptrolelistContext

	// IsCreategroupstmtContext differentiates from other interfaces.
	IsCreategroupstmtContext()
}

type CreategroupstmtContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyCreategroupstmtContext() *CreategroupstmtContext {
	var p = new(CreategroupstmtContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_creategroupstmt
	return p
}

func InitEmptyCreategroupstmtContext(p *CreategroupstmtContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_creategroupstmt
}

func (*CreategroupstmtContext) IsCreategroupstmtContext() {}

func NewCreategroupstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CreategroupstmtContext {
	var p = new(CreategroupstmtContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_creategroupstmt

	return p
}

func (s *CreategroupstmtContext) GetParser() antlr.Parser { return s.parser }

func (s *CreategroupstmtContext) CREATE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCREATE, 0)
}

func (s *CreategroupstmtContext) GROUP_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserGROUP_P, 0)
}

func (s *CreategroupstmtContext) Roleid() IRoleidContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IRoleidContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IRoleidContext)
}

func (s *CreategroupstmtContext) Opt_with() IOpt_withContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOpt_withContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOpt_withContext)
}

func (s *CreategroupstmtContext) Optrolelist() IOptrolelistContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOptrolelistContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOptrolelistContext)
}

func (s *CreategroupstmtContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *CreategroupstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *CreategroupstmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterCreategroupstmt(s)
	}
}

func (s *CreategroupstmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitCreategroupstmt(s)
	}
}

func (s *CreategroupstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitCreategroupstmt(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Creategroupstmt() (localctx ICreategroupstmtContext) {
	localctx = NewCreategroupstmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 36, PostgreSQLParserRULE_creategroupstmt)
	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1863)
		p.Match(PostgreSQLParserCREATE)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(1864)
		p.Match(PostgreSQLParserGROUP_P)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(1865)
		p.Roleid()
	}
	{
		p.SetState(1866)
		p.Opt_with()
	}
	{
		p.SetState(1867)
		p.Optrolelist()
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IAltergroupstmtContext is an interface to support dynamic dispatch.
type IAltergroupstmtContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	ALTER() antlr.TerminalNode
	GROUP_P() antlr.TerminalNode
	Rolespec() IRolespecContext
	Add_drop() IAdd_dropContext
	USER() antlr.TerminalNode
	Role_list() IRole_listContext

	// IsAltergroupstmtContext differentiates from other interfaces.
	IsAltergroupstmtContext()
}

type AltergroupstmtContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyAltergroupstmtContext() *AltergroupstmtContext {
	var p = new(AltergroupstmtContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_altergroupstmt
	return p
}

func InitEmptyAltergroupstmtContext(p *AltergroupstmtContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_altergroupstmt
}

func (*AltergroupstmtContext) IsAltergroupstmtContext() {}

func NewAltergroupstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AltergroupstmtContext {
	var p = new(AltergroupstmtContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_altergroupstmt

	return p
}

func (s *AltergroupstmtContext) GetParser() antlr.Parser { return s.parser }

func (s *AltergroupstmtContext) ALTER() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserALTER, 0)
}

func (s *AltergroupstmtContext) GROUP_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserGROUP_P, 0)
}

func (s *AltergroupstmtContext) Rolespec() IRolespecContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IRolespecContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IRolespecContext)
}

func (s *AltergroupstmtContext) Add_drop() IAdd_dropContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IAdd_dropContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IAdd_dropContext)
}

func (s *AltergroupstmtContext) USER() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserUSER, 0)
}

func (s *AltergroupstmtContext) Role_list() IRole_listContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IRole_listContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IRole_listContext)
}

func (s *AltergroupstmtContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *AltergroupstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *AltergroupstmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterAltergroupstmt(s)
	}
}

func (s *AltergroupstmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitAltergroupstmt(s)
	}
}

func (s *AltergroupstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitAltergroupstmt(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Altergroupstmt() (localctx IAltergroupstmtContext) {
	localctx = NewAltergroupstmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 38, PostgreSQLParserRULE_altergroupstmt)
	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1869)
		p.Match(PostgreSQLParserALTER)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(1870)
		p.Match(PostgreSQLParserGROUP_P)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(1871)
		p.Rolespec()
	}
	{
		p.SetState(1872)
		p.Add_drop()
	}
	{
		p.SetState(1873)
		p.Match(PostgreSQLParserUSER)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(1874)
		p.Role_list()
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IAdd_dropContext is an interface to support dynamic dispatch.
type IAdd_dropContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	ADD_P() antlr.TerminalNode
	DROP() antlr.TerminalNode

	// IsAdd_dropContext differentiates from other interfaces.
	IsAdd_dropContext()
}

type Add_dropContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyAdd_dropContext() *Add_dropContext {
	var p = new(Add_dropContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_add_drop
	return p
}

func InitEmptyAdd_dropContext(p *Add_dropContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_add_drop
}

func (*Add_dropContext) IsAdd_dropContext() {}

func NewAdd_dropContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Add_dropContext {
	var p = new(Add_dropContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_add_drop

	return p
}

func (s *Add_dropContext) GetParser() antlr.Parser { return s.parser }

func (s *Add_dropContext) ADD_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserADD_P, 0)
}

func (s *Add_dropContext) DROP() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserDROP, 0)
}

func (s *Add_dropContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Add_dropContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Add_dropContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterAdd_drop(s)
	}
}

func (s *Add_dropContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitAdd_drop(s)
	}
}

func (s *Add_dropContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitAdd_drop(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Add_drop() (localctx IAdd_dropContext) {
	localctx = NewAdd_dropContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 40, PostgreSQLParserRULE_add_drop)
	var _la int

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1876)
		_la = p.GetTokenStream().LA(1)

		if !(_la == PostgreSQLParserADD_P || _la == PostgreSQLParserDROP) {
			p.GetErrorHandler().RecoverInline(p)
		} else {
			p.GetErrorHandler().ReportMatch(p)
			p.Consume()
		}
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// ICreateschemastmtContext is an interface to support dynamic dispatch.
type ICreateschemastmtContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	CREATE() antlr.TerminalNode
	SCHEMA() antlr.TerminalNode
	Optschemaeltlist() IOptschemaeltlistContext
	Optschemaname() IOptschemanameContext
	AUTHORIZATION() antlr.TerminalNode
	Rolespec() IRolespecContext
	Colid() IColidContext
	IF_P() antlr.TerminalNode
	NOT() antlr.TerminalNode
	EXISTS() antlr.TerminalNode

	// IsCreateschemastmtContext differentiates from other interfaces.
	IsCreateschemastmtContext()
}

type CreateschemastmtContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyCreateschemastmtContext() *CreateschemastmtContext {
	var p = new(CreateschemastmtContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_createschemastmt
	return p
}

func InitEmptyCreateschemastmtContext(p *CreateschemastmtContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_createschemastmt
}

func (*CreateschemastmtContext) IsCreateschemastmtContext() {}

func NewCreateschemastmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CreateschemastmtContext {
	var p = new(CreateschemastmtContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_createschemastmt

	return p
}

func (s *CreateschemastmtContext) GetParser() antlr.Parser { return s.parser }

func (s *CreateschemastmtContext) CREATE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCREATE, 0)
}

func (s *CreateschemastmtContext) SCHEMA() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserSCHEMA, 0)
}

func (s *CreateschemastmtContext) Optschemaeltlist() IOptschemaeltlistContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOptschemaeltlistContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOptschemaeltlistContext)
}

func (s *CreateschemastmtContext) Optschemaname() IOptschemanameContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOptschemanameContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOptschemanameContext)
}

func (s *CreateschemastmtContext) AUTHORIZATION() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserAUTHORIZATION, 0)
}

func (s *CreateschemastmtContext) Rolespec() IRolespecContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IRolespecContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IRolespecContext)
}

func (s *CreateschemastmtContext) Colid() IColidContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IColidContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IColidContext)
}

func (s *CreateschemastmtContext) IF_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserIF_P, 0)
}

func (s *CreateschemastmtContext) NOT() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserNOT, 0)
}

func (s *CreateschemastmtContext) EXISTS() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserEXISTS, 0)
}

func (s *CreateschemastmtContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *CreateschemastmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *CreateschemastmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterCreateschemastmt(s)
	}
}

func (s *CreateschemastmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitCreateschemastmt(s)
	}
}

func (s *CreateschemastmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitCreateschemastmt(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Createschemastmt() (localctx ICreateschemastmtContext) {
	localctx = NewCreateschemastmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 42, PostgreSQLParserRULE_createschemastmt)
	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1878)
		p.Match(PostgreSQLParserCREATE)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(1879)
		p.Match(PostgreSQLParserSCHEMA)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	p.SetState(1883)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 13, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(1880)
			p.Match(PostgreSQLParserIF_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(1881)
			p.Match(PostgreSQLParserNOT)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(1882)
			p.Match(PostgreSQLParserEXISTS)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	} else if p.HasError() { // JIM
		goto errorExit
	}
	p.SetState(1890)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 14, p.GetParserRuleContext()) {
	case 1:
		{
			p.SetState(1885)
			p.Optschemaname()
		}
		{
			p.SetState(1886)
			p.Match(PostgreSQLParserAUTHORIZATION)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(1887)
			p.Rolespec()
		}

	case 2:
		{
			p.SetState(1889)
			p.Colid()
		}

	case antlr.ATNInvalidAltNumber:
		goto errorExit
	}
	{
		p.SetState(1892)
		p.Optschemaeltlist()
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IOptschemanameContext is an interface to support dynamic dispatch.
type IOptschemanameContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Colid() IColidContext

	// IsOptschemanameContext differentiates from other interfaces.
	IsOptschemanameContext()
}

type OptschemanameContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyOptschemanameContext() *OptschemanameContext {
	var p = new(OptschemanameContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_optschemaname
	return p
}

func InitEmptyOptschemanameContext(p *OptschemanameContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_optschemaname
}

func (*OptschemanameContext) IsOptschemanameContext() {}

func NewOptschemanameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *OptschemanameContext {
	var p = new(OptschemanameContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_optschemaname

	return p
}

func (s *OptschemanameContext) GetParser() antlr.Parser { return s.parser }

func (s *OptschemanameContext) Colid() IColidContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IColidContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IColidContext)
}

func (s *OptschemanameContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *OptschemanameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *OptschemanameContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterOptschemaname(s)
	}
}

func (s *OptschemanameContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitOptschemaname(s)
	}
}

func (s *OptschemanameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitOptschemaname(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Optschemaname() (localctx IOptschemanameContext) {
	localctx = NewOptschemanameContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 44, PostgreSQLParserRULE_optschemaname)
	p.SetState(1896)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetTokenStream().LA(1) {
	case PostgreSQLParserAND, PostgreSQLParserARRAY, PostgreSQLParserCOLLATE, PostgreSQLParserCOLUMN, PostgreSQLParserCONSTRAINT, PostgreSQLParserDEFAULT, PostgreSQLParserDO, PostgreSQLParserFETCH, PostgreSQLParserTABLE, PostgreSQLParserIS, PostgreSQLParserLEFT, PostgreSQLParserOUTER_P, PostgreSQLParserOVER, PostgreSQLParserRIGHT, PostgreSQLParserABORT_P, PostgreSQLParserABSOLUTE_P, PostgreSQLParserACCESS, PostgreSQLParserACTION, PostgreSQLParserADD_P, PostgreSQLParserADMIN, PostgreSQLParserAFTER, PostgreSQLParserAGGREGATE, PostgreSQLParserALSO, PostgreSQLParserALTER, PostgreSQLParserALWAYS, PostgreSQLParserASSERTION, PostgreSQLParserASSIGNMENT, PostgreSQLParserAT, PostgreSQLParserATTRIBUTE, PostgreSQLParserBACKWARD, PostgreSQLParserBEFORE, PostgreSQLParserBEGIN_P, PostgreSQLParserBY, PostgreSQLParserCACHE, PostgreSQLParserCALLED, PostgreSQLParserCASCADE, PostgreSQLParserCASCADED, PostgreSQLParserCATALOG, PostgreSQLParserCHAIN, PostgreSQLParserCHARACTERISTICS, PostgreSQLParserCHECKPOINT, PostgreSQLParserCLASS, PostgreSQLParserCLOSE, PostgreSQLParserCLUSTER, PostgreSQLParserCOMMENT, PostgreSQLParserCOMMENTS, PostgreSQLParserCOMMIT, PostgreSQLParserCOMMITTED, PostgreSQLParserCONFIGURATION, PostgreSQLParserCONNECTION, PostgreSQLParserCONSTRAINTS, PostgreSQLParserCONTENT_P, PostgreSQLParserCONTINUE_P, PostgreSQLParserCONVERSION_P, PostgreSQLParserCOPY, PostgreSQLParserCOST, PostgreSQLParserCSV, PostgreSQLParserCURSOR, PostgreSQLParserCYCLE, PostgreSQLParserDATA_P, PostgreSQLParserDATABASE, PostgreSQLParserDAY_P, PostgreSQLParserDEALLOCATE, PostgreSQLParserDECLARE, PostgreSQLParserDEFAULTS, PostgreSQLParserDEFERRED, PostgreSQLParserDEFINER, PostgreSQLParserDELETE_P, PostgreSQLParserDELIMITER, PostgreSQLParserDELIMITERS, PostgreSQLParserDICTIONARY, PostgreSQLParserDISABLE_P, PostgreSQLParserDISCARD, PostgreSQLParserDOCUMENT_P, PostgreSQLParserDOMAIN_P, PostgreSQLParserDOUBLE_P, PostgreSQLParserDROP, PostgreSQLParserEACH, PostgreSQLParserENABLE_P, PostgreSQLParserENCODING, PostgreSQLParserENCRYPTED, PostgreSQLParserENUM_P, PostgreSQLParserESCAPE, PostgreSQLParserEVENT, PostgreSQLParserEXCLUDE, PostgreSQLParserEXCLUDING, PostgreSQLParserEXCLUSIVE, PostgreSQLParserEXECUTE, PostgreSQLParserEXPLAIN, PostgreSQLParserEXTENSION, PostgreSQLParserEXTERNAL, PostgreSQLParserFAMILY, PostgreSQLParserFIRST_P, PostgreSQLParserFOLLOWING, PostgreSQLParserFORCE, PostgreSQLParserFORWARD, PostgreSQLParserFUNCTION, PostgreSQLParserFUNCTIONS, PostgreSQLParserGLOBAL, PostgreSQLParserGRANTED, PostgreSQLParserHANDLER, PostgreSQLParserHEADER_P, PostgreSQLParserHOLD, PostgreSQLParserHOUR_P, PostgreSQLParserIDENTITY_P, PostgreSQLParserIF_P, PostgreSQLParserIMMEDIATE, PostgreSQLParserIMMUTABLE, PostgreSQLParserIMPLICIT_P, PostgreSQLParserINCLUDING, PostgreSQLParserINCREMENT, PostgreSQLParserINDEX, PostgreSQLParserINDEXES, PostgreSQLParserINHERIT, PostgreSQLParserINHERITS, PostgreSQLParserINLINE_P, PostgreSQLParserINSENSITIVE, PostgreSQLParserINSERT, PostgreSQLParserINSTEAD, PostgreSQLParserINVOKER, PostgreSQLParserISOLATION, PostgreSQLParserKEY, PostgreSQLParserLABEL, PostgreSQLParserLANGUAGE, PostgreSQLParserLARGE_P, PostgreSQLParserLAST_P, PostgreSQLParserLEAKPROOF, PostgreSQLParserLEVEL, PostgreSQLParserLISTEN, PostgreSQLParserLOAD, PostgreSQLParserLOCAL, PostgreSQLParserLOCATION, PostgreSQLParserLOCK_P, PostgreSQLParserMAPPING, PostgreSQLParserMATCH, PostgreSQLParserMATERIALIZED, PostgreSQLParserMAXVALUE, PostgreSQLParserMINUTE_P, PostgreSQLParserMINVALUE, PostgreSQLParserMODE, PostgreSQLParserMONTH_P, PostgreSQLParserMOVE, PostgreSQLParserNAME_P, PostgreSQLParserNAMES, PostgreSQLParserNEXT, PostgreSQLParserNO, PostgreSQLParserNOTHING, PostgreSQLParserNOTIFY, PostgreSQLParserNOWAIT, PostgreSQLParserNULLS_P, PostgreSQLParserOBJECT_P, PostgreSQLParserOF, PostgreSQLParserOFF, PostgreSQLParserOIDS, PostgreSQLParserOPERATOR, PostgreSQLParserOPTION, PostgreSQLParserOPTIONS, PostgreSQLParserOWNED, PostgreSQLParserOWNER, PostgreSQLParserPARSER, PostgreSQLParserPARTIAL, PostgreSQLParserPARTITION, PostgreSQLParserPASSING, PostgreSQLParserPASSWORD, PostgreSQLParserPLANS, PostgreSQLParserPRECEDING, PostgreSQLParserPREPARE, PostgreSQLParserPREPARED, PostgreSQLParserPRESERVE, PostgreSQLParserPRIOR, PostgreSQLParserPRIVILEGES, PostgreSQLParserPROCEDURAL, PostgreSQLParserPROCEDURE, PostgreSQLParserPROGRAM, PostgreSQLParserQUOTE, PostgreSQLParserRANGE, PostgreSQLParserREAD, PostgreSQLParserREASSIGN, PostgreSQLParserRECHECK, PostgreSQLParserRECURSIVE, PostgreSQLParserREF, PostgreSQLParserREFRESH, PostgreSQLParserREINDEX, PostgreSQLParserRELATIVE_P, PostgreSQLParserRELEASE, PostgreSQLParserRENAME, PostgreSQLParserREPEATABLE, PostgreSQLParserREPLACE, PostgreSQLParserREPLICA, PostgreSQLParserRESET, PostgreSQLParserRESTART, PostgreSQLParserRESTRICT, PostgreSQLParserRETURNS, PostgreSQLParserREVOKE, PostgreSQLParserROLE, PostgreSQLParserROLLBACK, PostgreSQLParserROWS, PostgreSQLParserRULE, PostgreSQLParserSAVEPOINT, PostgreSQLParserSCHEMA, PostgreSQLParserSCROLL, PostgreSQLParserSEARCH, PostgreSQLParserSECOND_P, PostgreSQLParserSECURITY, PostgreSQLParserSEQUENCE, PostgreSQLParserSEQUENCES, PostgreSQLParserSERIALIZABLE, PostgreSQLParserSERVER, PostgreSQLParserSESSION, PostgreSQLParserSET, PostgreSQLParserSHARE, PostgreSQLParserSHOW, PostgreSQLParserSIMPLE, PostgreSQLParserSNAPSHOT, PostgreSQLParserSTABLE, PostgreSQLParserSTANDALONE_P, PostgreSQLParserSTART, PostgreSQLParserSTATEMENT, PostgreSQLParserSTATISTICS, PostgreSQLParserSTDIN, PostgreSQLParserSTDOUT, PostgreSQLParserSTORAGE, PostgreSQLParserSTRICT_P, PostgreSQLParserSTRIP_P, PostgreSQLParserSYSID, PostgreSQLParserSYSTEM_P, PostgreSQLParserTABLES, PostgreSQLParserTABLESPACE, PostgreSQLParserTEMP, PostgreSQLParserTEMPLATE, PostgreSQLParserTEMPORARY, PostgreSQLParserTEXT_P, PostgreSQLParserTRANSACTION, PostgreSQLParserTRIGGER, PostgreSQLParserTRUNCATE, PostgreSQLParserTRUSTED, PostgreSQLParserTYPE_P, PostgreSQLParserTYPES_P, PostgreSQLParserUNBOUNDED, PostgreSQLParserUNCOMMITTED, PostgreSQLParserUNENCRYPTED, PostgreSQLParserUNKNOWN, PostgreSQLParserUNLISTEN, PostgreSQLParserUNLOGGED, PostgreSQLParserUNTIL, PostgreSQLParserUPDATE, PostgreSQLParserVACUUM, PostgreSQLParserVALID, PostgreSQLParserVALIDATE, PostgreSQLParserVALIDATOR, PostgreSQLParserVARYING, PostgreSQLParserVERSION_P, PostgreSQLParserVIEW, PostgreSQLParserVOLATILE, PostgreSQLParserWHITESPACE_P, PostgreSQLParserWITHOUT, PostgreSQLParserWORK, PostgreSQLParserWRAPPER, PostgreSQLParserWRITE, PostgreSQLParserXML_P, PostgreSQLParserYEAR_P, PostgreSQLParserYES_P, PostgreSQLParserZONE, PostgreSQLParserBETWEEN, PostgreSQLParserBIGINT, PostgreSQLParserBIT, PostgreSQLParserBOOLEAN_P, PostgreSQLParserCHAR_P, PostgreSQLParserCHARACTER, PostgreSQLParserCOALESCE, PostgreSQLParserDEC, PostgreSQLParserDECIMAL_P, PostgreSQLParserEXISTS, PostgreSQLParserEXTRACT, PostgreSQLParserFLOAT_P, PostgreSQLParserGREATEST, PostgreSQLParserINOUT, PostgreSQLParserINT_P, PostgreSQLParserINTEGER, PostgreSQLParserINTERVAL, PostgreSQLParserLEAST, PostgreSQLParserNATIONAL, PostgreSQLParserNCHAR, PostgreSQLParserNONE, PostgreSQLParserNULLIF, PostgreSQLParserNUMERIC, PostgreSQLParserOVERLAY, PostgreSQLParserPOSITION, PostgreSQLParserPRECISION, PostgreSQLParserREAL, PostgreSQLParserROW, PostgreSQLParserSETOF, PostgreSQLParserSMALLINT, PostgreSQLParserSUBSTRING, PostgreSQLParserTIME, PostgreSQLParserTIMESTAMP, PostgreSQLParserTREAT, PostgreSQLParserTRIM, PostgreSQLParserVALUES, PostgreSQLParserVARCHAR, PostgreSQLParserXMLATTRIBUTES, PostgreSQLParserXMLCOMMENT, PostgreSQLParserXMLAGG, PostgreSQLParserXML_IS_WELL_FORMED, PostgreSQLParserXML_IS_WELL_FORMED_DOCUMENT, PostgreSQLParserXML_IS_WELL_FORMED_CONTENT, PostgreSQLParserXPATH, PostgreSQLParserXPATH_EXISTS, PostgreSQLParserXMLCONCAT, PostgreSQLParserXMLELEMENT, PostgreSQLParserXMLEXISTS, PostgreSQLParserXMLFOREST, PostgreSQLParserXMLPARSE, PostgreSQLParserXMLPI, PostgreSQLParserXMLROOT, PostgreSQLParserXMLSERIALIZE, PostgreSQLParserCALL, PostgreSQLParserCURRENT_P, PostgreSQLParserATTACH, PostgreSQLParserDETACH, PostgreSQLParserEXPRESSION, PostgreSQLParserGENERATED, PostgreSQLParserLOGGED, PostgreSQLParserSTORED, PostgreSQLParserINCLUDE, PostgreSQLParserROUTINE, PostgreSQLParserTRANSFORM, PostgreSQLParserIMPORT_P, PostgreSQLParserPOLICY, PostgreSQLParserMETHOD, PostgreSQLParserREFERENCING, PostgreSQLParserNEW, PostgreSQLParserOLD, PostgreSQLParserVALUE_P, PostgreSQLParserSUBSCRIPTION, PostgreSQLParserPUBLICATION, PostgreSQLParserOUT_P, PostgreSQLParserROUTINES, PostgreSQLParserSCHEMAS, PostgreSQLParserPROCEDURES, PostgreSQLParserINPUT_P, PostgreSQLParserSUPPORT, PostgreSQLParserPARALLEL, PostgreSQLParserSQL_P, PostgreSQLParserDEPENDS, PostgreSQLParserOVERRIDING, PostgreSQLParserCONFLICT, PostgreSQLParserSKIP_P, PostgreSQLParserLOCKED, PostgreSQLParserTIES, PostgreSQLParserROLLUP, PostgreSQLParserCUBE, PostgreSQLParserGROUPING, PostgreSQLParserSETS, PostgreSQLParserORDINALITY, PostgreSQLParserXMLTABLE, PostgreSQLParserCOLUMNS, PostgreSQLParserXMLNAMESPACES, PostgreSQLParserROWTYPE, PostgreSQLParserNORMALIZED, PostgreSQLParserWITHIN, PostgreSQLParserFILTER, PostgreSQLParserGROUPS, PostgreSQLParserOTHERS, PostgreSQLParserNFC, PostgreSQLParserNFD, PostgreSQLParserNFKC, PostgreSQLParserNFKD, PostgreSQLParserUESCAPE, PostgreSQLParserVIEWS, PostgreSQLParserNORMALIZE, PostgreSQLParserDUMP, PostgreSQLParserPRINT_STRICT_PARAMS, PostgreSQLParserVARIABLE_CONFLICT, PostgreSQLParserERROR, PostgreSQLParserUSE_VARIABLE, PostgreSQLParserUSE_COLUMN, PostgreSQLParserALIAS, PostgreSQLParserCONSTANT, PostgreSQLParserPERFORM, PostgreSQLParserGET, PostgreSQLParserDIAGNOSTICS, PostgreSQLParserSTACKED, PostgreSQLParserELSIF, PostgreSQLParserREVERSE, PostgreSQLParserSLICE, PostgreSQLParserEXIT, PostgreSQLParserRETURN, PostgreSQLParserQUERY, PostgreSQLParserRAISE, PostgreSQLParserSQLSTATE, PostgreSQLParserDEBUG, PostgreSQLParserLOG, PostgreSQLParserINFO, PostgreSQLParserNOTICE, PostgreSQLParserWARNING, PostgreSQLParserEXCEPTION, PostgreSQLParserASSERT, PostgreSQLParserOPEN, PostgreSQLParserABS, PostgreSQLParserCBRT, PostgreSQLParserCEIL, PostgreSQLParserCEILING, PostgreSQLParserDEGREES, PostgreSQLParserDIV, PostgreSQLParserEXP, PostgreSQLParserFACTORIAL, PostgreSQLParserFLOOR, PostgreSQLParserGCD, PostgreSQLParserLCM, PostgreSQLParserLN, PostgreSQLParserLOG10, PostgreSQLParserMIN_SCALE, PostgreSQLParserMOD, PostgreSQLParserPI, PostgreSQLParserPOWER, PostgreSQLParserRADIANS, PostgreSQLParserROUND, PostgreSQLParserSCALE, PostgreSQLParserSIGN, PostgreSQLParserSQRT, PostgreSQLParserTRIM_SCALE, PostgreSQLParserTRUNC, PostgreSQLParserWIDTH_BUCKET, PostgreSQLParserRANDOM, PostgreSQLParserSETSEED, PostgreSQLParserACOS, PostgreSQLParserACOSD, PostgreSQLParserASIN, PostgreSQLParserASIND, PostgreSQLParserATAN, PostgreSQLParserATAND, PostgreSQLParserATAN2, PostgreSQLParserATAN2D, PostgreSQLParserCOS, PostgreSQLParserCOSD, PostgreSQLParserCOT, PostgreSQLParserCOTD, PostgreSQLParserSIN, PostgreSQLParserSIND, PostgreSQLParserTAN, PostgreSQLParserTAND, PostgreSQLParserSINH, PostgreSQLParserCOSH, PostgreSQLParserTANH, PostgreSQLParserASINH, PostgreSQLParserACOSH, PostgreSQLParserATANH, PostgreSQLParserBIT_LENGTH, PostgreSQLParserCHAR_LENGTH, PostgreSQLParserCHARACTER_LENGTH, PostgreSQLParserLOWER, PostgreSQLParserOCTET_LENGTH, PostgreSQLParserUPPER, PostgreSQLParserASCII, PostgreSQLParserBTRIM, PostgreSQLParserCHR, PostgreSQLParserCONCAT, PostgreSQLParserCONCAT_WS, PostgreSQLParserFORMAT, PostgreSQLParserINITCAP, PostgreSQLParserLENGTH, PostgreSQLParserLPAD, PostgreSQLParserLTRIM, PostgreSQLParserMD5, PostgreSQLParserPARSE_IDENT, PostgreSQLParserPG_CLIENT_ENCODING, PostgreSQLParserQUOTE_IDENT, PostgreSQLParserQUOTE_LITERAL, PostgreSQLParserQUOTE_NULLABLE, PostgreSQLParserREGEXP_COUNT, PostgreSQLParserREGEXP_INSTR, PostgreSQLParserREGEXP_LIKE, PostgreSQLParserREGEXP_MATCH, PostgreSQLParserREGEXP_MATCHES, PostgreSQLParserREGEXP_REPLACE, PostgreSQLParserREGEXP_SPLIT_TO_ARRAY, PostgreSQLParserREGEXP_SPLIT_TO_TABLE, PostgreSQLParserREGEXP_SUBSTR, PostgreSQLParserREPEAT, PostgreSQLParserRPAD, PostgreSQLParserRTRIM, PostgreSQLParserSPLIT_PART, PostgreSQLParserSTARTS_WITH, PostgreSQLParserSTRING_TO_ARRAY, PostgreSQLParserSTRING_TO_TABLE, PostgreSQLParserSTRPOS, PostgreSQLParserSUBSTR, PostgreSQLParserTO_ASCII, PostgreSQLParserTO_HEX, PostgreSQLParserTRANSLATE, PostgreSQLParserUNISTR, PostgreSQLParserAGE, PostgreSQLParserCLOCK_TIMESTAMP, PostgreSQLParserDATE_BIN, PostgreSQLParserDATE_PART, PostgreSQLParserDATE_TRUNC, PostgreSQLParserISFINITE, PostgreSQLParserJUSTIFY_DAYS, PostgreSQLParserJUSTIFY_HOURS, PostgreSQLParserJUSTIFY_INTERVAL, PostgreSQLParserMAKE_DATE, PostgreSQLParserMAKE_INTERVAL, PostgreSQLParserMAKE_TIME, PostgreSQLParserMAKE_TIMESTAMP, PostgreSQLParserMAKE_TIMESTAMPTZ, PostgreSQLParserNOW, PostgreSQLParserSTATEMENT_TIMESTAMP, PostgreSQLParserTIMEOFDAY, PostgreSQLParserTRANSACTION_TIMESTAMP, PostgreSQLParserTO_TIMESTAMP, PostgreSQLParserTO_CHAR, PostgreSQLParserTO_DATE, PostgreSQLParserTO_NUMBER, PostgreSQLParserIdentifier, PostgreSQLParserQuotedIdentifier, PostgreSQLParserUnicodeQuotedIdentifier, PostgreSQLParserPLSQLVARIABLENAME, PostgreSQLParserPLSQLIDENTIFIER:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(1894)
			p.Colid()
		}

	case PostgreSQLParserAUTHORIZATION:
		p.EnterOuterAlt(localctx, 2)

	default:
		p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IOptschemaeltlistContext is an interface to support dynamic dispatch.
type IOptschemaeltlistContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	AllSchema_stmt() []ISchema_stmtContext
	Schema_stmt(i int) ISchema_stmtContext

	// IsOptschemaeltlistContext differentiates from other interfaces.
	IsOptschemaeltlistContext()
}

type OptschemaeltlistContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyOptschemaeltlistContext() *OptschemaeltlistContext {
	var p = new(OptschemaeltlistContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_optschemaeltlist
	return p
}

func InitEmptyOptschemaeltlistContext(p *OptschemaeltlistContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_optschemaeltlist
}

func (*OptschemaeltlistContext) IsOptschemaeltlistContext() {}

func NewOptschemaeltlistContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *OptschemaeltlistContext {
	var p = new(OptschemaeltlistContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_optschemaeltlist

	return p
}

func (s *OptschemaeltlistContext) GetParser() antlr.Parser { return s.parser }

func (s *OptschemaeltlistContext) AllSchema_stmt() []ISchema_stmtContext {
	children := s.GetChildren()
	len := 0
	for _, ctx := range children {
		if _, ok := ctx.(ISchema_stmtContext); ok {
			len++
		}
	}

	tst := make([]ISchema_stmtContext, len)
	i := 0
	for _, ctx := range children {
		if t, ok := ctx.(ISchema_stmtContext); ok {
			tst[i] = t.(ISchema_stmtContext)
			i++
		}
	}

	return tst
}

func (s *OptschemaeltlistContext) Schema_stmt(i int) ISchema_stmtContext {
	var t antlr.RuleContext
	j := 0
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ISchema_stmtContext); ok {
			if j == i {
				t = ctx.(antlr.RuleContext)
				break
			}
			j++
		}
	}

	if t == nil {
		return nil
	}

	return t.(ISchema_stmtContext)
}

func (s *OptschemaeltlistContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *OptschemaeltlistContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *OptschemaeltlistContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterOptschemaeltlist(s)
	}
}

func (s *OptschemaeltlistContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitOptschemaeltlist(s)
	}
}

func (s *OptschemaeltlistContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitOptschemaeltlist(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Optschemaeltlist() (localctx IOptschemaeltlistContext) {
	localctx = NewOptschemaeltlistContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 46, PostgreSQLParserRULE_optschemaeltlist)
	var _alt int

	p.EnterOuterAlt(localctx, 1)
	p.SetState(1901)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}
	_alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 16, p.GetParserRuleContext())
	if p.HasError() {
		goto errorExit
	}
	for _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
		if _alt == 1 {
			{
				p.SetState(1898)
				p.Schema_stmt()
			}

		}
		p.SetState(1903)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}
		_alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 16, p.GetParserRuleContext())
		if p.HasError() {
			goto errorExit
		}
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// ISchema_stmtContext is an interface to support dynamic dispatch.
type ISchema_stmtContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Createstmt() ICreatestmtContext
	Indexstmt() IIndexstmtContext
	Createseqstmt() ICreateseqstmtContext
	Createtrigstmt() ICreatetrigstmtContext
	Grantstmt() IGrantstmtContext
	Viewstmt() IViewstmtContext

	// IsSchema_stmtContext differentiates from other interfaces.
	IsSchema_stmtContext()
}

type Schema_stmtContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptySchema_stmtContext() *Schema_stmtContext {
	var p = new(Schema_stmtContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_schema_stmt
	return p
}

func InitEmptySchema_stmtContext(p *Schema_stmtContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_schema_stmt
}

func (*Schema_stmtContext) IsSchema_stmtContext() {}

func NewSchema_stmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Schema_stmtContext {
	var p = new(Schema_stmtContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_schema_stmt

	return p
}

func (s *Schema_stmtContext) GetParser() antlr.Parser { return s.parser }

func (s *Schema_stmtContext) Createstmt() ICreatestmtContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ICreatestmtContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ICreatestmtContext)
}

func (s *Schema_stmtContext) Indexstmt() IIndexstmtContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IIndexstmtContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IIndexstmtContext)
}

func (s *Schema_stmtContext) Createseqstmt() ICreateseqstmtContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ICreateseqstmtContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ICreateseqstmtContext)
}

func (s *Schema_stmtContext) Createtrigstmt() ICreatetrigstmtContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ICreatetrigstmtContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ICreatetrigstmtContext)
}

func (s *Schema_stmtContext) Grantstmt() IGrantstmtContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IGrantstmtContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IGrantstmtContext)
}

func (s *Schema_stmtContext) Viewstmt() IViewstmtContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IViewstmtContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IViewstmtContext)
}

func (s *Schema_stmtContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Schema_stmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Schema_stmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterSchema_stmt(s)
	}
}

func (s *Schema_stmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitSchema_stmt(s)
	}
}

func (s *Schema_stmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitSchema_stmt(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Schema_stmt() (localctx ISchema_stmtContext) {
	localctx = NewSchema_stmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 48, PostgreSQLParserRULE_schema_stmt)
	p.SetState(1910)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 17, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(1904)
			p.Createstmt()
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(1905)
			p.Indexstmt()
		}

	case 3:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(1906)
			p.Createseqstmt()
		}

	case 4:
		p.EnterOuterAlt(localctx, 4)
		{
			p.SetState(1907)
			p.Createtrigstmt()
		}

	case 5:
		p.EnterOuterAlt(localctx, 5)
		{
			p.SetState(1908)
			p.Grantstmt()
		}

	case 6:
		p.EnterOuterAlt(localctx, 6)
		{
			p.SetState(1909)
			p.Viewstmt()
		}

	case antlr.ATNInvalidAltNumber:
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IVariablesetstmtContext is an interface to support dynamic dispatch.
type IVariablesetstmtContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	SET() antlr.TerminalNode
	Set_rest() ISet_restContext
	LOCAL() antlr.TerminalNode
	SESSION() antlr.TerminalNode

	// IsVariablesetstmtContext differentiates from other interfaces.
	IsVariablesetstmtContext()
}

type VariablesetstmtContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyVariablesetstmtContext() *VariablesetstmtContext {
	var p = new(VariablesetstmtContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_variablesetstmt
	return p
}

func InitEmptyVariablesetstmtContext(p *VariablesetstmtContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_variablesetstmt
}

func (*VariablesetstmtContext) IsVariablesetstmtContext() {}

func NewVariablesetstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *VariablesetstmtContext {
	var p = new(VariablesetstmtContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_variablesetstmt

	return p
}

func (s *VariablesetstmtContext) GetParser() antlr.Parser { return s.parser }

func (s *VariablesetstmtContext) SET() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserSET, 0)
}

func (s *VariablesetstmtContext) Set_rest() ISet_restContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ISet_restContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ISet_restContext)
}

func (s *VariablesetstmtContext) LOCAL() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserLOCAL, 0)
}

func (s *VariablesetstmtContext) SESSION() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserSESSION, 0)
}

func (s *VariablesetstmtContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *VariablesetstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *VariablesetstmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterVariablesetstmt(s)
	}
}

func (s *VariablesetstmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitVariablesetstmt(s)
	}
}

func (s *VariablesetstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitVariablesetstmt(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Variablesetstmt() (localctx IVariablesetstmtContext) {
	localctx = NewVariablesetstmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 50, PostgreSQLParserRULE_variablesetstmt)
	var _la int

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1912)
		p.Match(PostgreSQLParserSET)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	p.SetState(1914)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 18, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(1913)
			_la = p.GetTokenStream().LA(1)

			if !(_la == PostgreSQLParserLOCAL || _la == PostgreSQLParserSESSION) {
				p.GetErrorHandler().RecoverInline(p)
			} else {
				p.GetErrorHandler().ReportMatch(p)
				p.Consume()
			}
		}

	} else if p.HasError() { // JIM
		goto errorExit
	}
	{
		p.SetState(1916)
		p.Set_rest()
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// ISet_restContext is an interface to support dynamic dispatch.
type ISet_restContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	TRANSACTION() antlr.TerminalNode
	Transaction_mode_list() ITransaction_mode_listContext
	SESSION() antlr.TerminalNode
	CHARACTERISTICS() antlr.TerminalNode
	AS() antlr.TerminalNode
	Set_rest_more() ISet_rest_moreContext

	// IsSet_restContext differentiates from other interfaces.
	IsSet_restContext()
}

type Set_restContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptySet_restContext() *Set_restContext {
	var p = new(Set_restContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_set_rest
	return p
}

func InitEmptySet_restContext(p *Set_restContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_set_rest
}

func (*Set_restContext) IsSet_restContext() {}

func NewSet_restContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Set_restContext {
	var p = new(Set_restContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_set_rest

	return p
}

func (s *Set_restContext) GetParser() antlr.Parser { return s.parser }

func (s *Set_restContext) TRANSACTION() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserTRANSACTION, 0)
}

func (s *Set_restContext) Transaction_mode_list() ITransaction_mode_listContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ITransaction_mode_listContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ITransaction_mode_listContext)
}

func (s *Set_restContext) SESSION() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserSESSION, 0)
}

func (s *Set_restContext) CHARACTERISTICS() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCHARACTERISTICS, 0)
}

func (s *Set_restContext) AS() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserAS, 0)
}

func (s *Set_restContext) Set_rest_more() ISet_rest_moreContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ISet_rest_moreContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ISet_rest_moreContext)
}

func (s *Set_restContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Set_restContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Set_restContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterSet_rest(s)
	}
}

func (s *Set_restContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitSet_rest(s)
	}
}

func (s *Set_restContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitSet_rest(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Set_rest() (localctx ISet_restContext) {
	localctx = NewSet_restContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 52, PostgreSQLParserRULE_set_rest)
	p.SetState(1926)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 19, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(1918)
			p.Match(PostgreSQLParserTRANSACTION)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(1919)
			p.Transaction_mode_list()
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(1920)
			p.Match(PostgreSQLParserSESSION)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(1921)
			p.Match(PostgreSQLParserCHARACTERISTICS)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(1922)
			p.Match(PostgreSQLParserAS)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(1923)
			p.Match(PostgreSQLParserTRANSACTION)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(1924)
			p.Transaction_mode_list()
		}

	case 3:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(1925)
			p.Set_rest_more()
		}

	case antlr.ATNInvalidAltNumber:
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IGeneric_setContext is an interface to support dynamic dispatch.
type IGeneric_setContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Var_name() IVar_nameContext
	Var_list() IVar_listContext
	TO() antlr.TerminalNode
	EQUAL() antlr.TerminalNode

	// IsGeneric_setContext differentiates from other interfaces.
	IsGeneric_setContext()
}

type Generic_setContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyGeneric_setContext() *Generic_setContext {
	var p = new(Generic_setContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_generic_set
	return p
}

func InitEmptyGeneric_setContext(p *Generic_setContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_generic_set
}

func (*Generic_setContext) IsGeneric_setContext() {}

func NewGeneric_setContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Generic_setContext {
	var p = new(Generic_setContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_generic_set

	return p
}

func (s *Generic_setContext) GetParser() antlr.Parser { return s.parser }

func (s *Generic_setContext) Var_name() IVar_nameContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IVar_nameContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IVar_nameContext)
}

func (s *Generic_setContext) Var_list() IVar_listContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IVar_listContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IVar_listContext)
}

func (s *Generic_setContext) TO() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserTO, 0)
}

func (s *Generic_setContext) EQUAL() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserEQUAL, 0)
}

func (s *Generic_setContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Generic_setContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Generic_setContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterGeneric_set(s)
	}
}

func (s *Generic_setContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitGeneric_set(s)
	}
}

func (s *Generic_setContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitGeneric_set(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Generic_set() (localctx IGeneric_setContext) {
	localctx = NewGeneric_setContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 54, PostgreSQLParserRULE_generic_set)
	var _la int

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1928)
		p.Var_name()
	}
	{
		p.SetState(1929)
		_la = p.GetTokenStream().LA(1)

		if !(_la == PostgreSQLParserEQUAL || _la == PostgreSQLParserTO) {
			p.GetErrorHandler().RecoverInline(p)
		} else {
			p.GetErrorHandler().ReportMatch(p)
			p.Consume()
		}
	}
	{
		p.SetState(1930)
		p.Var_list()
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// ISet_rest_moreContext is an interface to support dynamic dispatch.
type ISet_rest_moreContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Generic_set() IGeneric_setContext
	Var_name() IVar_nameContext
	FROM() antlr.TerminalNode
	CURRENT_P() antlr.TerminalNode
	TIME() antlr.TerminalNode
	ZONE() antlr.TerminalNode
	Zone_value() IZone_valueContext
	CATALOG() antlr.TerminalNode
	Sconst() ISconstContext
	SCHEMA() antlr.TerminalNode
	NAMES() antlr.TerminalNode
	Opt_encoding() IOpt_encodingContext
	ROLE() antlr.TerminalNode
	Nonreservedword_or_sconst() INonreservedword_or_sconstContext
	SESSION() antlr.TerminalNode
	AUTHORIZATION() antlr.TerminalNode
	XML_P() antlr.TerminalNode
	OPTION() antlr.TerminalNode
	Document_or_content() IDocument_or_contentContext
	TRANSACTION() antlr.TerminalNode
	SNAPSHOT() antlr.TerminalNode

	// IsSet_rest_moreContext differentiates from other interfaces.
	IsSet_rest_moreContext()
}

type Set_rest_moreContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptySet_rest_moreContext() *Set_rest_moreContext {
	var p = new(Set_rest_moreContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_set_rest_more
	return p
}

func InitEmptySet_rest_moreContext(p *Set_rest_moreContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_set_rest_more
}

func (*Set_rest_moreContext) IsSet_rest_moreContext() {}

func NewSet_rest_moreContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Set_rest_moreContext {
	var p = new(Set_rest_moreContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_set_rest_more

	return p
}

func (s *Set_rest_moreContext) GetParser() antlr.Parser { return s.parser }

func (s *Set_rest_moreContext) Generic_set() IGeneric_setContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IGeneric_setContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IGeneric_setContext)
}

func (s *Set_rest_moreContext) Var_name() IVar_nameContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IVar_nameContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IVar_nameContext)
}

func (s *Set_rest_moreContext) FROM() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserFROM, 0)
}

func (s *Set_rest_moreContext) CURRENT_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCURRENT_P, 0)
}

func (s *Set_rest_moreContext) TIME() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserTIME, 0)
}

func (s *Set_rest_moreContext) ZONE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserZONE, 0)
}

func (s *Set_rest_moreContext) Zone_value() IZone_valueContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IZone_valueContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IZone_valueContext)
}

func (s *Set_rest_moreContext) CATALOG() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCATALOG, 0)
}

func (s *Set_rest_moreContext) Sconst() ISconstContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ISconstContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ISconstContext)
}

func (s *Set_rest_moreContext) SCHEMA() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserSCHEMA, 0)
}

func (s *Set_rest_moreContext) NAMES() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserNAMES, 0)
}

func (s *Set_rest_moreContext) Opt_encoding() IOpt_encodingContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOpt_encodingContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOpt_encodingContext)
}

func (s *Set_rest_moreContext) ROLE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserROLE, 0)
}

func (s *Set_rest_moreContext) Nonreservedword_or_sconst() INonreservedword_or_sconstContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(INonreservedword_or_sconstContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(INonreservedword_or_sconstContext)
}

func (s *Set_rest_moreContext) SESSION() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserSESSION, 0)
}

func (s *Set_rest_moreContext) AUTHORIZATION() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserAUTHORIZATION, 0)
}

func (s *Set_rest_moreContext) XML_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserXML_P, 0)
}

func (s *Set_rest_moreContext) OPTION() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserOPTION, 0)
}

func (s *Set_rest_moreContext) Document_or_content() IDocument_or_contentContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IDocument_or_contentContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IDocument_or_contentContext)
}

func (s *Set_rest_moreContext) TRANSACTION() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserTRANSACTION, 0)
}

func (s *Set_rest_moreContext) SNAPSHOT() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserSNAPSHOT, 0)
}

func (s *Set_rest_moreContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Set_rest_moreContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Set_rest_moreContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterSet_rest_more(s)
	}
}

func (s *Set_rest_moreContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitSet_rest_more(s)
	}
}

func (s *Set_rest_moreContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitSet_rest_more(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Set_rest_more() (localctx ISet_rest_moreContext) {
	localctx = NewSet_rest_moreContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 56, PostgreSQLParserRULE_set_rest_more)
	p.SetState(1957)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 20, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(1932)
			p.Generic_set()
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(1933)
			p.Var_name()
		}
		{
			p.SetState(1934)
			p.Match(PostgreSQLParserFROM)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(1935)
			p.Match(PostgreSQLParserCURRENT_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 3:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(1937)
			p.Match(PostgreSQLParserTIME)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(1938)
			p.Match(PostgreSQLParserZONE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(1939)
			p.Zone_value()
		}

	case 4:
		p.EnterOuterAlt(localctx, 4)
		{
			p.SetState(1940)
			p.Match(PostgreSQLParserCATALOG)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(1941)
			p.Sconst()
		}

	case 5:
		p.EnterOuterAlt(localctx, 5)
		{
			p.SetState(1942)
			p.Match(PostgreSQLParserSCHEMA)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(1943)
			p.Sconst()
		}

	case 6:
		p.EnterOuterAlt(localctx, 6)
		{
			p.SetState(1944)
			p.Match(PostgreSQLParserNAMES)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(1945)
			p.Opt_encoding()
		}

	case 7:
		p.EnterOuterAlt(localctx, 7)
		{
			p.SetState(1946)
			p.Match(PostgreSQLParserROLE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(1947)
			p.Nonreservedword_or_sconst()
		}

	case 8:
		p.EnterOuterAlt(localctx, 8)
		{
			p.SetState(1948)
			p.Match(PostgreSQLParserSESSION)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(1949)
			p.Match(PostgreSQLParserAUTHORIZATION)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(1950)
			p.Nonreservedword_or_sconst()
		}

	case 9:
		p.EnterOuterAlt(localctx, 9)
		{
			p.SetState(1951)
			p.Match(PostgreSQLParserXML_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(1952)
			p.Match(PostgreSQLParserOPTION)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(1953)
			p.Document_or_content()
		}

	case 10:
		p.EnterOuterAlt(localctx, 10)
		{
			p.SetState(1954)
			p.Match(PostgreSQLParserTRANSACTION)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(1955)
			p.Match(PostgreSQLParserSNAPSHOT)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(1956)
			p.Sconst()
		}

	case antlr.ATNInvalidAltNumber:
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IVar_nameContext is an interface to support dynamic dispatch.
type IVar_nameContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	AllColid() []IColidContext
	Colid(i int) IColidContext
	AllDOT() []antlr.TerminalNode
	DOT(i int) antlr.TerminalNode

	// IsVar_nameContext differentiates from other interfaces.
	IsVar_nameContext()
}

type Var_nameContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyVar_nameContext() *Var_nameContext {
	var p = new(Var_nameContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_var_name
	return p
}

func InitEmptyVar_nameContext(p *Var_nameContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_var_name
}

func (*Var_nameContext) IsVar_nameContext() {}

func NewVar_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Var_nameContext {
	var p = new(Var_nameContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_var_name

	return p
}

func (s *Var_nameContext) GetParser() antlr.Parser { return s.parser }

func (s *Var_nameContext) AllColid() []IColidContext {
	children := s.GetChildren()
	len := 0
	for _, ctx := range children {
		if _, ok := ctx.(IColidContext); ok {
			len++
		}
	}

	tst := make([]IColidContext, len)
	i := 0
	for _, ctx := range children {
		if t, ok := ctx.(IColidContext); ok {
			tst[i] = t.(IColidContext)
			i++
		}
	}

	return tst
}

func (s *Var_nameContext) Colid(i int) IColidContext {
	var t antlr.RuleContext
	j := 0
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IColidContext); ok {
			if j == i {
				t = ctx.(antlr.RuleContext)
				break
			}
			j++
		}
	}

	if t == nil {
		return nil
	}

	return t.(IColidContext)
}

func (s *Var_nameContext) AllDOT() []antlr.TerminalNode {
	return s.GetTokens(PostgreSQLParserDOT)
}

func (s *Var_nameContext) DOT(i int) antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserDOT, i)
}

func (s *Var_nameContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Var_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Var_nameContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterVar_name(s)
	}
}

func (s *Var_nameContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitVar_name(s)
	}
}

func (s *Var_nameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitVar_name(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Var_name() (localctx IVar_nameContext) {
	localctx = NewVar_nameContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 58, PostgreSQLParserRULE_var_name)
	var _la int

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1959)
		p.Colid()
	}
	p.SetState(1964)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}
	_la = p.GetTokenStream().LA(1)

	for _la == PostgreSQLParserDOT {
		{
			p.SetState(1960)
			p.Match(PostgreSQLParserDOT)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(1961)
			p.Colid()
		}

		p.SetState(1966)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}
		_la = p.GetTokenStream().LA(1)
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IVar_listContext is an interface to support dynamic dispatch.
type IVar_listContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	AllVar_value() []IVar_valueContext
	Var_value(i int) IVar_valueContext
	AllCOMMA() []antlr.TerminalNode
	COMMA(i int) antlr.TerminalNode

	// IsVar_listContext differentiates from other interfaces.
	IsVar_listContext()
}

type Var_listContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyVar_listContext() *Var_listContext {
	var p = new(Var_listContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_var_list
	return p
}

func InitEmptyVar_listContext(p *Var_listContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_var_list
}

func (*Var_listContext) IsVar_listContext() {}

func NewVar_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Var_listContext {
	var p = new(Var_listContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_var_list

	return p
}

func (s *Var_listContext) GetParser() antlr.Parser { return s.parser }

func (s *Var_listContext) AllVar_value() []IVar_valueContext {
	children := s.GetChildren()
	len := 0
	for _, ctx := range children {
		if _, ok := ctx.(IVar_valueContext); ok {
			len++
		}
	}

	tst := make([]IVar_valueContext, len)
	i := 0
	for _, ctx := range children {
		if t, ok := ctx.(IVar_valueContext); ok {
			tst[i] = t.(IVar_valueContext)
			i++
		}
	}

	return tst
}

func (s *Var_listContext) Var_value(i int) IVar_valueContext {
	var t antlr.RuleContext
	j := 0
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IVar_valueContext); ok {
			if j == i {
				t = ctx.(antlr.RuleContext)
				break
			}
			j++
		}
	}

	if t == nil {
		return nil
	}

	return t.(IVar_valueContext)
}

func (s *Var_listContext) AllCOMMA() []antlr.TerminalNode {
	return s.GetTokens(PostgreSQLParserCOMMA)
}

func (s *Var_listContext) COMMA(i int) antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCOMMA, i)
}

func (s *Var_listContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Var_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Var_listContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterVar_list(s)
	}
}

func (s *Var_listContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitVar_list(s)
	}
}

func (s *Var_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitVar_list(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Var_list() (localctx IVar_listContext) {
	localctx = NewVar_listContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 60, PostgreSQLParserRULE_var_list)
	var _la int

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1967)
		p.Var_value()
	}
	p.SetState(1972)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}
	_la = p.GetTokenStream().LA(1)

	for _la == PostgreSQLParserCOMMA {
		{
			p.SetState(1968)
			p.Match(PostgreSQLParserCOMMA)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(1969)
			p.Var_value()
		}

		p.SetState(1974)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}
		_la = p.GetTokenStream().LA(1)
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IVar_valueContext is an interface to support dynamic dispatch.
type IVar_valueContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Opt_boolean_or_string() IOpt_boolean_or_stringContext
	Numericonly() INumericonlyContext

	// IsVar_valueContext differentiates from other interfaces.
	IsVar_valueContext()
}

type Var_valueContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyVar_valueContext() *Var_valueContext {
	var p = new(Var_valueContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_var_value
	return p
}

func InitEmptyVar_valueContext(p *Var_valueContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_var_value
}

func (*Var_valueContext) IsVar_valueContext() {}

func NewVar_valueContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Var_valueContext {
	var p = new(Var_valueContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_var_value

	return p
}

func (s *Var_valueContext) GetParser() antlr.Parser { return s.parser }

func (s *Var_valueContext) Opt_boolean_or_string() IOpt_boolean_or_stringContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOpt_boolean_or_stringContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOpt_boolean_or_stringContext)
}

func (s *Var_valueContext) Numericonly() INumericonlyContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(INumericonlyContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(INumericonlyContext)
}

func (s *Var_valueContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Var_valueContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Var_valueContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterVar_value(s)
	}
}

func (s *Var_valueContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitVar_value(s)
	}
}

func (s *Var_valueContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitVar_value(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Var_value() (localctx IVar_valueContext) {
	localctx = NewVar_valueContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 62, PostgreSQLParserRULE_var_value)
	p.SetState(1977)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetTokenStream().LA(1) {
	case PostgreSQLParserAND, PostgreSQLParserARRAY, PostgreSQLParserCOLLATE, PostgreSQLParserCOLUMN, PostgreSQLParserCONSTRAINT, PostgreSQLParserDEFAULT, PostgreSQLParserDO, PostgreSQLParserFALSE_P, PostgreSQLParserFETCH, PostgreSQLParserON, PostgreSQLParserTABLE, PostgreSQLParserTRUE_P, PostgreSQLParserAUTHORIZATION, PostgreSQLParserBINARY, PostgreSQLParserCOLLATION, PostgreSQLParserCONCURRENTLY, PostgreSQLParserCROSS, PostgreSQLParserCURRENT_SCHEMA, PostgreSQLParserFREEZE, PostgreSQLParserFULL, PostgreSQLParserILIKE, PostgreSQLParserINNER_P, PostgreSQLParserIS, PostgreSQLParserISNULL, PostgreSQLParserJOIN, PostgreSQLParserLIKE, PostgreSQLParserNATURAL, PostgreSQLParserNOTNULL, PostgreSQLParserOUTER_P, PostgreSQLParserOVER, PostgreSQLParserOVERLAPS, PostgreSQLParserSIMILAR, PostgreSQLParserVERBOSE, PostgreSQLParserABORT_P, PostgreSQLParserABSOLUTE_P, PostgreSQLParserACCESS, PostgreSQLParserACTION, PostgreSQLParserADD_P, PostgreSQLParserADMIN, PostgreSQLParserAFTER, PostgreSQLParserAGGREGATE, PostgreSQLParserALSO, PostgreSQLParserALTER, PostgreSQLParserALWAYS, PostgreSQLParserASSERTION, PostgreSQLParserASSIGNMENT, PostgreSQLParserAT, PostgreSQLParserATTRIBUTE, PostgreSQLParserBACKWARD, PostgreSQLParserBEFORE, PostgreSQLParserBEGIN_P, PostgreSQLParserBY, PostgreSQLParserCACHE, PostgreSQLParserCALLED, PostgreSQLParserCASCADE, PostgreSQLParserCASCADED, PostgreSQLParserCATALOG, PostgreSQLParserCHAIN, PostgreSQLParserCHARACTERISTICS, PostgreSQLParserCHECKPOINT, PostgreSQLParserCLASS, PostgreSQLParserCLOSE, PostgreSQLParserCLUSTER, PostgreSQLParserCOMMENT, PostgreSQLParserCOMMENTS, PostgreSQLParserCOMMIT, PostgreSQLParserCOMMITTED, PostgreSQLParserCONFIGURATION, PostgreSQLParserCONNECTION, PostgreSQLParserCONSTRAINTS, PostgreSQLParserCONTENT_P, PostgreSQLParserCONTINUE_P, PostgreSQLParserCONVERSION_P, PostgreSQLParserCOPY, PostgreSQLParserCOST, PostgreSQLParserCSV, PostgreSQLParserCURSOR, PostgreSQLParserCYCLE, PostgreSQLParserDATA_P, PostgreSQLParserDATABASE, PostgreSQLParserDAY_P, PostgreSQLParserDEALLOCATE, PostgreSQLParserDECLARE, PostgreSQLParserDEFAULTS, PostgreSQLParserDEFERRED, PostgreSQLParserDEFINER, PostgreSQLParserDELETE_P, PostgreSQLParserDELIMITER, PostgreSQLParserDELIMITERS, PostgreSQLParserDICTIONARY, PostgreSQLParserDISABLE_P, PostgreSQLParserDISCARD, PostgreSQLParserDOCUMENT_P, PostgreSQLParserDOMAIN_P, PostgreSQLParserDOUBLE_P, PostgreSQLParserDROP, PostgreSQLParserEACH, PostgreSQLParserENABLE_P, PostgreSQLParserENCODING, PostgreSQLParserENCRYPTED, PostgreSQLParserENUM_P, PostgreSQLParserESCAPE, PostgreSQLParserEVENT, PostgreSQLParserEXCLUDE, PostgreSQLParserEXCLUDING, PostgreSQLParserEXCLUSIVE, PostgreSQLParserEXECUTE, PostgreSQLParserEXPLAIN, PostgreSQLParserEXTENSION, PostgreSQLParserEXTERNAL, PostgreSQLParserFAMILY, PostgreSQLParserFIRST_P, PostgreSQLParserFOLLOWING, PostgreSQLParserFORCE, PostgreSQLParserFORWARD, PostgreSQLParserFUNCTION, PostgreSQLParserFUNCTIONS, PostgreSQLParserGLOBAL, PostgreSQLParserGRANTED, PostgreSQLParserHANDLER, PostgreSQLParserHEADER_P, PostgreSQLParserHOLD, PostgreSQLParserHOUR_P, PostgreSQLParserIDENTITY_P, PostgreSQLParserIF_P, PostgreSQLParserIMMEDIATE, PostgreSQLParserIMMUTABLE, PostgreSQLParserIMPLICIT_P, PostgreSQLParserINCLUDING, PostgreSQLParserINCREMENT, PostgreSQLParserINDEX, PostgreSQLParserINDEXES, PostgreSQLParserINHERIT, PostgreSQLParserINHERITS, PostgreSQLParserINLINE_P, PostgreSQLParserINSENSITIVE, PostgreSQLParserINSERT, PostgreSQLParserINSTEAD, PostgreSQLParserINVOKER, PostgreSQLParserISOLATION, PostgreSQLParserKEY, PostgreSQLParserLABEL, PostgreSQLParserLANGUAGE, PostgreSQLParserLARGE_P, PostgreSQLParserLAST_P, PostgreSQLParserLEAKPROOF, PostgreSQLParserLEVEL, PostgreSQLParserLISTEN, PostgreSQLParserLOAD, PostgreSQLParserLOCAL, PostgreSQLParserLOCATION, PostgreSQLParserLOCK_P, PostgreSQLParserMAPPING, PostgreSQLParserMATCH, PostgreSQLParserMATERIALIZED, PostgreSQLParserMAXVALUE, PostgreSQLParserMINUTE_P, PostgreSQLParserMINVALUE, PostgreSQLParserMODE, PostgreSQLParserMONTH_P, PostgreSQLParserMOVE, PostgreSQLParserNAME_P, PostgreSQLParserNAMES, PostgreSQLParserNEXT, PostgreSQLParserNO, PostgreSQLParserNOTHING, PostgreSQLParserNOTIFY, PostgreSQLParserNOWAIT, PostgreSQLParserNULLS_P, PostgreSQLParserOBJECT_P, PostgreSQLParserOF, PostgreSQLParserOFF, PostgreSQLParserOIDS, PostgreSQLParserOPERATOR, PostgreSQLParserOPTION, PostgreSQLParserOPTIONS, PostgreSQLParserOWNED, PostgreSQLParserOWNER, PostgreSQLParserPARSER, PostgreSQLParserPARTIAL, PostgreSQLParserPARTITION, PostgreSQLParserPASSING, PostgreSQLParserPASSWORD, PostgreSQLParserPLANS, PostgreSQLParserPRECEDING, PostgreSQLParserPREPARE, PostgreSQLParserPREPARED, PostgreSQLParserPRESERVE, PostgreSQLParserPRIOR, PostgreSQLParserPRIVILEGES, PostgreSQLParserPROCEDURAL, PostgreSQLParserPROCEDURE, PostgreSQLParserPROGRAM, PostgreSQLParserQUOTE, PostgreSQLParserRANGE, PostgreSQLParserREAD, PostgreSQLParserREASSIGN, PostgreSQLParserRECHECK, PostgreSQLParserRECURSIVE, PostgreSQLParserREF, PostgreSQLParserREFRESH, PostgreSQLParserREINDEX, PostgreSQLParserRELATIVE_P, PostgreSQLParserRELEASE, PostgreSQLParserRENAME, PostgreSQLParserREPEATABLE, PostgreSQLParserREPLACE, PostgreSQLParserREPLICA, PostgreSQLParserRESET, PostgreSQLParserRESTART, PostgreSQLParserRESTRICT, PostgreSQLParserRETURNS, PostgreSQLParserREVOKE, PostgreSQLParserROLE, PostgreSQLParserROLLBACK, PostgreSQLParserROWS, PostgreSQLParserRULE, PostgreSQLParserSAVEPOINT, PostgreSQLParserSCHEMA, PostgreSQLParserSCROLL, PostgreSQLParserSEARCH, PostgreSQLParserSECOND_P, PostgreSQLParserSECURITY, PostgreSQLParserSEQUENCE, PostgreSQLParserSEQUENCES, PostgreSQLParserSERIALIZABLE, PostgreSQLParserSERVER, PostgreSQLParserSESSION, PostgreSQLParserSET, PostgreSQLParserSHARE, PostgreSQLParserSHOW, PostgreSQLParserSIMPLE, PostgreSQLParserSNAPSHOT, PostgreSQLParserSTABLE, PostgreSQLParserSTANDALONE_P, PostgreSQLParserSTART, PostgreSQLParserSTATEMENT, PostgreSQLParserSTATISTICS, PostgreSQLParserSTDIN, PostgreSQLParserSTDOUT, PostgreSQLParserSTORAGE, PostgreSQLParserSTRICT_P, PostgreSQLParserSTRIP_P, PostgreSQLParserSYSID, PostgreSQLParserSYSTEM_P, PostgreSQLParserTABLES, PostgreSQLParserTABLESPACE, PostgreSQLParserTEMP, PostgreSQLParserTEMPLATE, PostgreSQLParserTEMPORARY, PostgreSQLParserTEXT_P, PostgreSQLParserTRANSACTION, PostgreSQLParserTRIGGER, PostgreSQLParserTRUNCATE, PostgreSQLParserTRUSTED, PostgreSQLParserTYPE_P, PostgreSQLParserTYPES_P, PostgreSQLParserUNBOUNDED, PostgreSQLParserUNCOMMITTED, PostgreSQLParserUNENCRYPTED, PostgreSQLParserUNKNOWN, PostgreSQLParserUNLISTEN, PostgreSQLParserUNLOGGED, PostgreSQLParserUNTIL, PostgreSQLParserUPDATE, PostgreSQLParserVACUUM, PostgreSQLParserVALID, PostgreSQLParserVALIDATE, PostgreSQLParserVALIDATOR, PostgreSQLParserVARYING, PostgreSQLParserVERSION_P, PostgreSQLParserVIEW, PostgreSQLParserVOLATILE, PostgreSQLParserWHITESPACE_P, PostgreSQLParserWITHOUT, PostgreSQLParserWORK, PostgreSQLParserWRAPPER, PostgreSQLParserWRITE, PostgreSQLParserXML_P, PostgreSQLParserYEAR_P, PostgreSQLParserYES_P, PostgreSQLParserZONE, PostgreSQLParserBETWEEN, PostgreSQLParserBIGINT, PostgreSQLParserBIT, PostgreSQLParserBOOLEAN_P, PostgreSQLParserCHAR_P, PostgreSQLParserCHARACTER, PostgreSQLParserCOALESCE, PostgreSQLParserDEC, PostgreSQLParserDECIMAL_P, PostgreSQLParserEXISTS, PostgreSQLParserEXTRACT, PostgreSQLParserFLOAT_P, PostgreSQLParserGREATEST, PostgreSQLParserINOUT, PostgreSQLParserINT_P, PostgreSQLParserINTEGER, PostgreSQLParserINTERVAL, PostgreSQLParserLEAST, PostgreSQLParserNATIONAL, PostgreSQLParserNCHAR, PostgreSQLParserNONE, PostgreSQLParserNULLIF, PostgreSQLParserNUMERIC, PostgreSQLParserOVERLAY, PostgreSQLParserPOSITION, PostgreSQLParserPRECISION, PostgreSQLParserREAL, PostgreSQLParserROW, PostgreSQLParserSETOF, PostgreSQLParserSMALLINT, PostgreSQLParserSUBSTRING, PostgreSQLParserTIME, PostgreSQLParserTIMESTAMP, PostgreSQLParserTREAT, PostgreSQLParserTRIM, PostgreSQLParserVALUES, PostgreSQLParserVARCHAR, PostgreSQLParserXMLATTRIBUTES, PostgreSQLParserXMLCOMMENT, PostgreSQLParserXMLAGG, PostgreSQLParserXML_IS_WELL_FORMED, PostgreSQLParserXML_IS_WELL_FORMED_DOCUMENT, PostgreSQLParserXML_IS_WELL_FORMED_CONTENT, PostgreSQLParserXPATH, PostgreSQLParserXPATH_EXISTS, PostgreSQLParserXMLCONCAT, PostgreSQLParserXMLELEMENT, PostgreSQLParserXMLEXISTS, PostgreSQLParserXMLFOREST, PostgreSQLParserXMLPARSE, PostgreSQLParserXMLPI, PostgreSQLParserXMLROOT, PostgreSQLParserXMLSERIALIZE, PostgreSQLParserCALL, PostgreSQLParserCURRENT_P, PostgreSQLParserATTACH, PostgreSQLParserDETACH, PostgreSQLParserEXPRESSION, PostgreSQLParserGENERATED, PostgreSQLParserLOGGED, PostgreSQLParserSTORED, PostgreSQLParserINCLUDE, PostgreSQLParserROUTINE, PostgreSQLParserTRANSFORM, PostgreSQLParserIMPORT_P, PostgreSQLParserPOLICY, PostgreSQLParserMETHOD, PostgreSQLParserREFERENCING, PostgreSQLParserNEW, PostgreSQLParserOLD, PostgreSQLParserVALUE_P, PostgreSQLParserSUBSCRIPTION, PostgreSQLParserPUBLICATION, PostgreSQLParserOUT_P, PostgreSQLParserROUTINES, PostgreSQLParserSCHEMAS, PostgreSQLParserPROCEDURES, PostgreSQLParserINPUT_P, PostgreSQLParserSUPPORT, PostgreSQLParserPARALLEL, PostgreSQLParserSQL_P, PostgreSQLParserDEPENDS, PostgreSQLParserOVERRIDING, PostgreSQLParserCONFLICT, PostgreSQLParserSKIP_P, PostgreSQLParserLOCKED, PostgreSQLParserTIES, PostgreSQLParserROLLUP, PostgreSQLParserCUBE, PostgreSQLParserGROUPING, PostgreSQLParserSETS, PostgreSQLParserTABLESAMPLE, PostgreSQLParserORDINALITY, PostgreSQLParserXMLTABLE, PostgreSQLParserCOLUMNS, PostgreSQLParserXMLNAMESPACES, PostgreSQLParserROWTYPE, PostgreSQLParserNORMALIZED, PostgreSQLParserWITHIN, PostgreSQLParserFILTER, PostgreSQLParserGROUPS, PostgreSQLParserOTHERS, PostgreSQLParserNFC, PostgreSQLParserNFD, PostgreSQLParserNFKC, PostgreSQLParserNFKD, PostgreSQLParserUESCAPE, PostgreSQLParserVIEWS, PostgreSQLParserNORMALIZE, PostgreSQLParserDUMP, PostgreSQLParserPRINT_STRICT_PARAMS, PostgreSQLParserVARIABLE_CONFLICT, PostgreSQLParserERROR, PostgreSQLParserUSE_VARIABLE, PostgreSQLParserUSE_COLUMN, PostgreSQLParserALIAS, PostgreSQLParserCONSTANT, PostgreSQLParserPERFORM, PostgreSQLParserGET, PostgreSQLParserDIAGNOSTICS, PostgreSQLParserSTACKED, PostgreSQLParserELSIF, PostgreSQLParserREVERSE, PostgreSQLParserSLICE, PostgreSQLParserEXIT, PostgreSQLParserRETURN, PostgreSQLParserQUERY, PostgreSQLParserRAISE, PostgreSQLParserSQLSTATE, PostgreSQLParserDEBUG, PostgreSQLParserLOG, PostgreSQLParserINFO, PostgreSQLParserNOTICE, PostgreSQLParserWARNING, PostgreSQLParserEXCEPTION, PostgreSQLParserASSERT, PostgreSQLParserOPEN, PostgreSQLParserABS, PostgreSQLParserCBRT, PostgreSQLParserCEIL, PostgreSQLParserCEILING, PostgreSQLParserDEGREES, PostgreSQLParserDIV, PostgreSQLParserEXP, PostgreSQLParserFACTORIAL, PostgreSQLParserFLOOR, PostgreSQLParserGCD, PostgreSQLParserLCM, PostgreSQLParserLN, PostgreSQLParserLOG10, PostgreSQLParserMIN_SCALE, PostgreSQLParserMOD, PostgreSQLParserPI, PostgreSQLParserPOWER, PostgreSQLParserRADIANS, PostgreSQLParserROUND, PostgreSQLParserSCALE, PostgreSQLParserSIGN, PostgreSQLParserSQRT, PostgreSQLParserTRIM_SCALE, PostgreSQLParserTRUNC, PostgreSQLParserWIDTH_BUCKET, PostgreSQLParserRANDOM, PostgreSQLParserSETSEED, PostgreSQLParserACOS, PostgreSQLParserACOSD, PostgreSQLParserASIN, PostgreSQLParserASIND, PostgreSQLParserATAN, PostgreSQLParserATAND, PostgreSQLParserATAN2, PostgreSQLParserATAN2D, PostgreSQLParserCOS, PostgreSQLParserCOSD, PostgreSQLParserCOT, PostgreSQLParserCOTD, PostgreSQLParserSIN, PostgreSQLParserSIND, PostgreSQLParserTAN, PostgreSQLParserTAND, PostgreSQLParserSINH, PostgreSQLParserCOSH, PostgreSQLParserTANH, PostgreSQLParserASINH, PostgreSQLParserACOSH, PostgreSQLParserATANH, PostgreSQLParserBIT_LENGTH, PostgreSQLParserCHAR_LENGTH, PostgreSQLParserCHARACTER_LENGTH, PostgreSQLParserLOWER, PostgreSQLParserOCTET_LENGTH, PostgreSQLParserUPPER, PostgreSQLParserASCII, PostgreSQLParserBTRIM, PostgreSQLParserCHR, PostgreSQLParserCONCAT, PostgreSQLParserCONCAT_WS, PostgreSQLParserFORMAT, PostgreSQLParserINITCAP, PostgreSQLParserLENGTH, PostgreSQLParserLPAD, PostgreSQLParserLTRIM, PostgreSQLParserMD5, PostgreSQLParserPARSE_IDENT, PostgreSQLParserPG_CLIENT_ENCODING, PostgreSQLParserQUOTE_IDENT, PostgreSQLParserQUOTE_LITERAL, PostgreSQLParserQUOTE_NULLABLE, PostgreSQLParserREGEXP_COUNT, PostgreSQLParserREGEXP_INSTR, PostgreSQLParserREGEXP_LIKE, PostgreSQLParserREGEXP_MATCH, PostgreSQLParserREGEXP_MATCHES, PostgreSQLParserREGEXP_REPLACE, PostgreSQLParserREGEXP_SPLIT_TO_ARRAY, PostgreSQLParserREGEXP_SPLIT_TO_TABLE, PostgreSQLParserREGEXP_SUBSTR, PostgreSQLParserREPEAT, PostgreSQLParserRPAD, PostgreSQLParserRTRIM, PostgreSQLParserSPLIT_PART, PostgreSQLParserSTARTS_WITH, PostgreSQLParserSTRING_TO_ARRAY, PostgreSQLParserSTRING_TO_TABLE, PostgreSQLParserSTRPOS, PostgreSQLParserSUBSTR, PostgreSQLParserTO_ASCII, PostgreSQLParserTO_HEX, PostgreSQLParserTRANSLATE, PostgreSQLParserUNISTR, PostgreSQLParserAGE, PostgreSQLParserCLOCK_TIMESTAMP, PostgreSQLParserDATE_BIN, PostgreSQLParserDATE_PART, PostgreSQLParserDATE_TRUNC, PostgreSQLParserISFINITE, PostgreSQLParserJUSTIFY_DAYS, PostgreSQLParserJUSTIFY_HOURS, PostgreSQLParserJUSTIFY_INTERVAL, PostgreSQLParserMAKE_DATE, PostgreSQLParserMAKE_INTERVAL, PostgreSQLParserMAKE_TIME, PostgreSQLParserMAKE_TIMESTAMP, PostgreSQLParserMAKE_TIMESTAMPTZ, PostgreSQLParserNOW, PostgreSQLParserSTATEMENT_TIMESTAMP, PostgreSQLParserTIMEOFDAY, PostgreSQLParserTRANSACTION_TIMESTAMP, PostgreSQLParserTO_TIMESTAMP, PostgreSQLParserTO_CHAR, PostgreSQLParserTO_DATE, PostgreSQLParserTO_NUMBER, PostgreSQLParserIdentifier, PostgreSQLParserQuotedIdentifier, PostgreSQLParserUnicodeQuotedIdentifier, PostgreSQLParserStringConstant, PostgreSQLParserUnicodeEscapeStringConstant, PostgreSQLParserBeginDollarStringConstant, PostgreSQLParserPLSQLVARIABLENAME, PostgreSQLParserPLSQLIDENTIFIER, PostgreSQLParserEscapeStringConstant:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(1975)
			p.Opt_boolean_or_string()
		}

	case PostgreSQLParserPLUS, PostgreSQLParserMINUS, PostgreSQLParserIntegral, PostgreSQLParserNumeric:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(1976)
			p.Numericonly()
		}

	default:
		p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IIso_levelContext is an interface to support dynamic dispatch.
type IIso_levelContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	READ() antlr.TerminalNode
	UNCOMMITTED() antlr.TerminalNode
	COMMITTED() antlr.TerminalNode
	REPEATABLE() antlr.TerminalNode
	SERIALIZABLE() antlr.TerminalNode

	// IsIso_levelContext differentiates from other interfaces.
	IsIso_levelContext()
}

type Iso_levelContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyIso_levelContext() *Iso_levelContext {
	var p = new(Iso_levelContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_iso_level
	return p
}

func InitEmptyIso_levelContext(p *Iso_levelContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_iso_level
}

func (*Iso_levelContext) IsIso_levelContext() {}

func NewIso_levelContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Iso_levelContext {
	var p = new(Iso_levelContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_iso_level

	return p
}

func (s *Iso_levelContext) GetParser() antlr.Parser { return s.parser }

func (s *Iso_levelContext) READ() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserREAD, 0)
}

func (s *Iso_levelContext) UNCOMMITTED() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserUNCOMMITTED, 0)
}

func (s *Iso_levelContext) COMMITTED() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCOMMITTED, 0)
}

func (s *Iso_levelContext) REPEATABLE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserREPEATABLE, 0)
}

func (s *Iso_levelContext) SERIALIZABLE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserSERIALIZABLE, 0)
}

func (s *Iso_levelContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Iso_levelContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Iso_levelContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterIso_level(s)
	}
}

func (s *Iso_levelContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitIso_level(s)
	}
}

func (s *Iso_levelContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitIso_level(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Iso_level() (localctx IIso_levelContext) {
	localctx = NewIso_levelContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 64, PostgreSQLParserRULE_iso_level)
	var _la int

	p.SetState(1984)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetTokenStream().LA(1) {
	case PostgreSQLParserREAD:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(1979)
			p.Match(PostgreSQLParserREAD)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(1980)
			_la = p.GetTokenStream().LA(1)

			if !(_la == PostgreSQLParserCOMMITTED || _la == PostgreSQLParserUNCOMMITTED) {
				p.GetErrorHandler().RecoverInline(p)
			} else {
				p.GetErrorHandler().ReportMatch(p)
				p.Consume()
			}
		}

	case PostgreSQLParserREPEATABLE:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(1981)
			p.Match(PostgreSQLParserREPEATABLE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(1982)
			p.Match(PostgreSQLParserREAD)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case PostgreSQLParserSERIALIZABLE:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(1983)
			p.Match(PostgreSQLParserSERIALIZABLE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	default:
		p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IOpt_boolean_or_stringContext is an interface to support dynamic dispatch.
type IOpt_boolean_or_stringContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	TRUE_P() antlr.TerminalNode
	FALSE_P() antlr.TerminalNode
	ON() antlr.TerminalNode
	Nonreservedword_or_sconst() INonreservedword_or_sconstContext

	// IsOpt_boolean_or_stringContext differentiates from other interfaces.
	IsOpt_boolean_or_stringContext()
}

type Opt_boolean_or_stringContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyOpt_boolean_or_stringContext() *Opt_boolean_or_stringContext {
	var p = new(Opt_boolean_or_stringContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opt_boolean_or_string
	return p
}

func InitEmptyOpt_boolean_or_stringContext(p *Opt_boolean_or_stringContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opt_boolean_or_string
}

func (*Opt_boolean_or_stringContext) IsOpt_boolean_or_stringContext() {}

func NewOpt_boolean_or_stringContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_boolean_or_stringContext {
	var p = new(Opt_boolean_or_stringContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_opt_boolean_or_string

	return p
}

func (s *Opt_boolean_or_stringContext) GetParser() antlr.Parser { return s.parser }

func (s *Opt_boolean_or_stringContext) TRUE_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserTRUE_P, 0)
}

func (s *Opt_boolean_or_stringContext) FALSE_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserFALSE_P, 0)
}

func (s *Opt_boolean_or_stringContext) ON() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserON, 0)
}

func (s *Opt_boolean_or_stringContext) Nonreservedword_or_sconst() INonreservedword_or_sconstContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(INonreservedword_or_sconstContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(INonreservedword_or_sconstContext)
}

func (s *Opt_boolean_or_stringContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Opt_boolean_or_stringContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Opt_boolean_or_stringContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterOpt_boolean_or_string(s)
	}
}

func (s *Opt_boolean_or_stringContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitOpt_boolean_or_string(s)
	}
}

func (s *Opt_boolean_or_stringContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitOpt_boolean_or_string(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Opt_boolean_or_string() (localctx IOpt_boolean_or_stringContext) {
	localctx = NewOpt_boolean_or_stringContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 66, PostgreSQLParserRULE_opt_boolean_or_string)
	p.SetState(1990)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetTokenStream().LA(1) {
	case PostgreSQLParserTRUE_P:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(1986)
			p.Match(PostgreSQLParserTRUE_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case PostgreSQLParserFALSE_P:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(1987)
			p.Match(PostgreSQLParserFALSE_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case PostgreSQLParserON:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(1988)
			p.Match(PostgreSQLParserON)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case PostgreSQLParserAND, PostgreSQLParserARRAY, PostgreSQLParserCOLLATE, PostgreSQLParserCOLUMN, PostgreSQLParserCONSTRAINT, PostgreSQLParserDEFAULT, PostgreSQLParserDO, PostgreSQLParserFETCH, PostgreSQLParserTABLE, PostgreSQLParserAUTHORIZATION, PostgreSQLParserBINARY, PostgreSQLParserCOLLATION, PostgreSQLParserCONCURRENTLY, PostgreSQLParserCROSS, PostgreSQLParserCURRENT_SCHEMA, PostgreSQLParserFREEZE, PostgreSQLParserFULL, PostgreSQLParserILIKE, PostgreSQLParserINNER_P, PostgreSQLParserIS, PostgreSQLParserISNULL, PostgreSQLParserJOIN, PostgreSQLParserLIKE, PostgreSQLParserNATURAL, PostgreSQLParserNOTNULL, PostgreSQLParserOUTER_P, PostgreSQLParserOVER, PostgreSQLParserOVERLAPS, PostgreSQLParserSIMILAR, PostgreSQLParserVERBOSE, PostgreSQLParserABORT_P, PostgreSQLParserABSOLUTE_P, PostgreSQLParserACCESS, PostgreSQLParserACTION, PostgreSQLParserADD_P, PostgreSQLParserADMIN, PostgreSQLParserAFTER, PostgreSQLParserAGGREGATE, PostgreSQLParserALSO, PostgreSQLParserALTER, PostgreSQLParserALWAYS, PostgreSQLParserASSERTION, PostgreSQLParserASSIGNMENT, PostgreSQLParserAT, PostgreSQLParserATTRIBUTE, PostgreSQLParserBACKWARD, PostgreSQLParserBEFORE, PostgreSQLParserBEGIN_P, PostgreSQLParserBY, PostgreSQLParserCACHE, PostgreSQLParserCALLED, PostgreSQLParserCASCADE, PostgreSQLParserCASCADED, PostgreSQLParserCATALOG, PostgreSQLParserCHAIN, PostgreSQLParserCHARACTERISTICS, PostgreSQLParserCHECKPOINT, PostgreSQLParserCLASS, PostgreSQLParserCLOSE, PostgreSQLParserCLUSTER, PostgreSQLParserCOMMENT, PostgreSQLParserCOMMENTS, PostgreSQLParserCOMMIT, PostgreSQLParserCOMMITTED, PostgreSQLParserCONFIGURATION, PostgreSQLParserCONNECTION, PostgreSQLParserCONSTRAINTS, PostgreSQLParserCONTENT_P, PostgreSQLParserCONTINUE_P, PostgreSQLParserCONVERSION_P, PostgreSQLParserCOPY, PostgreSQLParserCOST, PostgreSQLParserCSV, PostgreSQLParserCURSOR, PostgreSQLParserCYCLE, PostgreSQLParserDATA_P, PostgreSQLParserDATABASE, PostgreSQLParserDAY_P, PostgreSQLParserDEALLOCATE, PostgreSQLParserDECLARE, PostgreSQLParserDEFAULTS, PostgreSQLParserDEFERRED, PostgreSQLParserDEFINER, PostgreSQLParserDELETE_P, PostgreSQLParserDELIMITER, PostgreSQLParserDELIMITERS, PostgreSQLParserDICTIONARY, PostgreSQLParserDISABLE_P, PostgreSQLParserDISCARD, PostgreSQLParserDOCUMENT_P, PostgreSQLParserDOMAIN_P, PostgreSQLParserDOUBLE_P, PostgreSQLParserDROP, PostgreSQLParserEACH, PostgreSQLParserENABLE_P, PostgreSQLParserENCODING, PostgreSQLParserENCRYPTED, PostgreSQLParserENUM_P, PostgreSQLParserESCAPE, PostgreSQLParserEVENT, PostgreSQLParserEXCLUDE, PostgreSQLParserEXCLUDING, PostgreSQLParserEXCLUSIVE, PostgreSQLParserEXECUTE, PostgreSQLParserEXPLAIN, PostgreSQLParserEXTENSION, PostgreSQLParserEXTERNAL, PostgreSQLParserFAMILY, PostgreSQLParserFIRST_P, PostgreSQLParserFOLLOWING, PostgreSQLParserFORCE, PostgreSQLParserFORWARD, PostgreSQLParserFUNCTION, PostgreSQLParserFUNCTIONS, PostgreSQLParserGLOBAL, PostgreSQLParserGRANTED, PostgreSQLParserHANDLER, PostgreSQLParserHEADER_P, PostgreSQLParserHOLD, PostgreSQLParserHOUR_P, PostgreSQLParserIDENTITY_P, PostgreSQLParserIF_P, PostgreSQLParserIMMEDIATE, PostgreSQLParserIMMUTABLE, PostgreSQLParserIMPLICIT_P, PostgreSQLParserINCLUDING, PostgreSQLParserINCREMENT, PostgreSQLParserINDEX, PostgreSQLParserINDEXES, PostgreSQLParserINHERIT, PostgreSQLParserINHERITS, PostgreSQLParserINLINE_P, PostgreSQLParserINSENSITIVE, PostgreSQLParserINSERT, PostgreSQLParserINSTEAD, PostgreSQLParserINVOKER, PostgreSQLParserISOLATION, PostgreSQLParserKEY, PostgreSQLParserLABEL, PostgreSQLParserLANGUAGE, PostgreSQLParserLARGE_P, PostgreSQLParserLAST_P, PostgreSQLParserLEAKPROOF, PostgreSQLParserLEVEL, PostgreSQLParserLISTEN, PostgreSQLParserLOAD, PostgreSQLParserLOCAL, PostgreSQLParserLOCATION, PostgreSQLParserLOCK_P, PostgreSQLParserMAPPING, PostgreSQLParserMATCH, PostgreSQLParserMATERIALIZED, PostgreSQLParserMAXVALUE, PostgreSQLParserMINUTE_P, PostgreSQLParserMINVALUE, PostgreSQLParserMODE, PostgreSQLParserMONTH_P, PostgreSQLParserMOVE, PostgreSQLParserNAME_P, PostgreSQLParserNAMES, PostgreSQLParserNEXT, PostgreSQLParserNO, PostgreSQLParserNOTHING, PostgreSQLParserNOTIFY, PostgreSQLParserNOWAIT, PostgreSQLParserNULLS_P, PostgreSQLParserOBJECT_P, PostgreSQLParserOF, PostgreSQLParserOFF, PostgreSQLParserOIDS, PostgreSQLParserOPERATOR, PostgreSQLParserOPTION, PostgreSQLParserOPTIONS, PostgreSQLParserOWNED, PostgreSQLParserOWNER, PostgreSQLParserPARSER, PostgreSQLParserPARTIAL, PostgreSQLParserPARTITION, PostgreSQLParserPASSING, PostgreSQLParserPASSWORD, PostgreSQLParserPLANS, PostgreSQLParserPRECEDING, PostgreSQLParserPREPARE, PostgreSQLParserPREPARED, PostgreSQLParserPRESERVE, PostgreSQLParserPRIOR, PostgreSQLParserPRIVILEGES, PostgreSQLParserPROCEDURAL, PostgreSQLParserPROCEDURE, PostgreSQLParserPROGRAM, PostgreSQLParserQUOTE, PostgreSQLParserRANGE, PostgreSQLParserREAD, PostgreSQLParserREASSIGN, PostgreSQLParserRECHECK, PostgreSQLParserRECURSIVE, PostgreSQLParserREF, PostgreSQLParserREFRESH, PostgreSQLParserREINDEX, PostgreSQLParserRELATIVE_P, PostgreSQLParserRELEASE, PostgreSQLParserRENAME, PostgreSQLParserREPEATABLE, PostgreSQLParserREPLACE, PostgreSQLParserREPLICA, PostgreSQLParserRESET, PostgreSQLParserRESTART, PostgreSQLParserRESTRICT, PostgreSQLParserRETURNS, PostgreSQLParserREVOKE, PostgreSQLParserROLE, PostgreSQLParserROLLBACK, PostgreSQLParserROWS, PostgreSQLParserRULE, PostgreSQLParserSAVEPOINT, PostgreSQLParserSCHEMA, PostgreSQLParserSCROLL, PostgreSQLParserSEARCH, PostgreSQLParserSECOND_P, PostgreSQLParserSECURITY, PostgreSQLParserSEQUENCE, PostgreSQLParserSEQUENCES, PostgreSQLParserSERIALIZABLE, PostgreSQLParserSERVER, PostgreSQLParserSESSION, PostgreSQLParserSET, PostgreSQLParserSHARE, PostgreSQLParserSHOW, PostgreSQLParserSIMPLE, PostgreSQLParserSNAPSHOT, PostgreSQLParserSTABLE, PostgreSQLParserSTANDALONE_P, PostgreSQLParserSTART, PostgreSQLParserSTATEMENT, PostgreSQLParserSTATISTICS, PostgreSQLParserSTDIN, PostgreSQLParserSTDOUT, PostgreSQLParserSTORAGE, PostgreSQLParserSTRICT_P, PostgreSQLParserSTRIP_P, PostgreSQLParserSYSID, PostgreSQLParserSYSTEM_P, PostgreSQLParserTABLES, PostgreSQLParserTABLESPACE, PostgreSQLParserTEMP, PostgreSQLParserTEMPLATE, PostgreSQLParserTEMPORARY, PostgreSQLParserTEXT_P, PostgreSQLParserTRANSACTION, PostgreSQLParserTRIGGER, PostgreSQLParserTRUNCATE, PostgreSQLParserTRUSTED, PostgreSQLParserTYPE_P, PostgreSQLParserTYPES_P, PostgreSQLParserUNBOUNDED, PostgreSQLParserUNCOMMITTED, PostgreSQLParserUNENCRYPTED, PostgreSQLParserUNKNOWN, PostgreSQLParserUNLISTEN, PostgreSQLParserUNLOGGED, PostgreSQLParserUNTIL, PostgreSQLParserUPDATE, PostgreSQLParserVACUUM, PostgreSQLParserVALID, PostgreSQLParserVALIDATE, PostgreSQLParserVALIDATOR, PostgreSQLParserVARYING, PostgreSQLParserVERSION_P, PostgreSQLParserVIEW, PostgreSQLParserVOLATILE, PostgreSQLParserWHITESPACE_P, PostgreSQLParserWITHOUT, PostgreSQLParserWORK, PostgreSQLParserWRAPPER, PostgreSQLParserWRITE, PostgreSQLParserXML_P, PostgreSQLParserYEAR_P, PostgreSQLParserYES_P, PostgreSQLParserZONE, PostgreSQLParserBETWEEN, PostgreSQLParserBIGINT, PostgreSQLParserBIT, PostgreSQLParserBOOLEAN_P, PostgreSQLParserCHAR_P, PostgreSQLParserCHARACTER, PostgreSQLParserCOALESCE, PostgreSQLParserDEC, PostgreSQLParserDECIMAL_P, PostgreSQLParserEXISTS, PostgreSQLParserEXTRACT, PostgreSQLParserFLOAT_P, PostgreSQLParserGREATEST, PostgreSQLParserINOUT, PostgreSQLParserINT_P, PostgreSQLParserINTEGER, PostgreSQLParserINTERVAL, PostgreSQLParserLEAST, PostgreSQLParserNATIONAL, PostgreSQLParserNCHAR, PostgreSQLParserNONE, PostgreSQLParserNULLIF, PostgreSQLParserNUMERIC, PostgreSQLParserOVERLAY, PostgreSQLParserPOSITION, PostgreSQLParserPRECISION, PostgreSQLParserREAL, PostgreSQLParserROW, PostgreSQLParserSETOF, PostgreSQLParserSMALLINT, PostgreSQLParserSUBSTRING, PostgreSQLParserTIME, PostgreSQLParserTIMESTAMP, PostgreSQLParserTREAT, PostgreSQLParserTRIM, PostgreSQLParserVALUES, PostgreSQLParserVARCHAR, PostgreSQLParserXMLATTRIBUTES, PostgreSQLParserXMLCOMMENT, PostgreSQLParserXMLAGG, PostgreSQLParserXML_IS_WELL_FORMED, PostgreSQLParserXML_IS_WELL_FORMED_DOCUMENT, PostgreSQLParserXML_IS_WELL_FORMED_CONTENT, PostgreSQLParserXPATH, PostgreSQLParserXPATH_EXISTS, PostgreSQLParserXMLCONCAT, PostgreSQLParserXMLELEMENT, PostgreSQLParserXMLEXISTS, PostgreSQLParserXMLFOREST, PostgreSQLParserXMLPARSE, PostgreSQLParserXMLPI, PostgreSQLParserXMLROOT, PostgreSQLParserXMLSERIALIZE, PostgreSQLParserCALL, PostgreSQLParserCURRENT_P, PostgreSQLParserATTACH, PostgreSQLParserDETACH, PostgreSQLParserEXPRESSION, PostgreSQLParserGENERATED, PostgreSQLParserLOGGED, PostgreSQLParserSTORED, PostgreSQLParserINCLUDE, PostgreSQLParserROUTINE, PostgreSQLParserTRANSFORM, PostgreSQLParserIMPORT_P, PostgreSQLParserPOLICY, PostgreSQLParserMETHOD, PostgreSQLParserREFERENCING, PostgreSQLParserNEW, PostgreSQLParserOLD, PostgreSQLParserVALUE_P, PostgreSQLParserSUBSCRIPTION, PostgreSQLParserPUBLICATION, PostgreSQLParserOUT_P, PostgreSQLParserROUTINES, PostgreSQLParserSCHEMAS, PostgreSQLParserPROCEDURES, PostgreSQLParserINPUT_P, PostgreSQLParserSUPPORT, PostgreSQLParserPARALLEL, PostgreSQLParserSQL_P, PostgreSQLParserDEPENDS, PostgreSQLParserOVERRIDING, PostgreSQLParserCONFLICT, PostgreSQLParserSKIP_P, PostgreSQLParserLOCKED, PostgreSQLParserTIES, PostgreSQLParserROLLUP, PostgreSQLParserCUBE, PostgreSQLParserGROUPING, PostgreSQLParserSETS, PostgreSQLParserTABLESAMPLE, PostgreSQLParserORDINALITY, PostgreSQLParserXMLTABLE, PostgreSQLParserCOLUMNS, PostgreSQLParserXMLNAMESPACES, PostgreSQLParserROWTYPE, PostgreSQLParserNORMALIZED, PostgreSQLParserWITHIN, PostgreSQLParserFILTER, PostgreSQLParserGROUPS, PostgreSQLParserOTHERS, PostgreSQLParserNFC, PostgreSQLParserNFD, PostgreSQLParserNFKC, PostgreSQLParserNFKD, PostgreSQLParserUESCAPE, PostgreSQLParserVIEWS, PostgreSQLParserNORMALIZE, PostgreSQLParserDUMP, PostgreSQLParserPRINT_STRICT_PARAMS, PostgreSQLParserVARIABLE_CONFLICT, PostgreSQLParserERROR, PostgreSQLParserUSE_VARIABLE, PostgreSQLParserUSE_COLUMN, PostgreSQLParserALIAS, PostgreSQLParserCONSTANT, PostgreSQLParserPERFORM, PostgreSQLParserGET, PostgreSQLParserDIAGNOSTICS, PostgreSQLParserSTACKED, PostgreSQLParserELSIF, PostgreSQLParserREVERSE, PostgreSQLParserSLICE, PostgreSQLParserEXIT, PostgreSQLParserRETURN, PostgreSQLParserQUERY, PostgreSQLParserRAISE, PostgreSQLParserSQLSTATE, PostgreSQLParserDEBUG, PostgreSQLParserLOG, PostgreSQLParserINFO, PostgreSQLParserNOTICE, PostgreSQLParserWARNING, PostgreSQLParserEXCEPTION, PostgreSQLParserASSERT, PostgreSQLParserOPEN, PostgreSQLParserABS, PostgreSQLParserCBRT, PostgreSQLParserCEIL, PostgreSQLParserCEILING, PostgreSQLParserDEGREES, PostgreSQLParserDIV, PostgreSQLParserEXP, PostgreSQLParserFACTORIAL, PostgreSQLParserFLOOR, PostgreSQLParserGCD, PostgreSQLParserLCM, PostgreSQLParserLN, PostgreSQLParserLOG10, PostgreSQLParserMIN_SCALE, PostgreSQLParserMOD, PostgreSQLParserPI, PostgreSQLParserPOWER, PostgreSQLParserRADIANS, PostgreSQLParserROUND, PostgreSQLParserSCALE, PostgreSQLParserSIGN, PostgreSQLParserSQRT, PostgreSQLParserTRIM_SCALE, PostgreSQLParserTRUNC, PostgreSQLParserWIDTH_BUCKET, PostgreSQLParserRANDOM, PostgreSQLParserSETSEED, PostgreSQLParserACOS, PostgreSQLParserACOSD, PostgreSQLParserASIN, PostgreSQLParserASIND, PostgreSQLParserATAN, PostgreSQLParserATAND, PostgreSQLParserATAN2, PostgreSQLParserATAN2D, PostgreSQLParserCOS, PostgreSQLParserCOSD, PostgreSQLParserCOT, PostgreSQLParserCOTD, PostgreSQLParserSIN, PostgreSQLParserSIND, PostgreSQLParserTAN, PostgreSQLParserTAND, PostgreSQLParserSINH, PostgreSQLParserCOSH, PostgreSQLParserTANH, PostgreSQLParserASINH, PostgreSQLParserACOSH, PostgreSQLParserATANH, PostgreSQLParserBIT_LENGTH, PostgreSQLParserCHAR_LENGTH, PostgreSQLParserCHARACTER_LENGTH, PostgreSQLParserLOWER, PostgreSQLParserOCTET_LENGTH, PostgreSQLParserUPPER, PostgreSQLParserASCII, PostgreSQLParserBTRIM, PostgreSQLParserCHR, PostgreSQLParserCONCAT, PostgreSQLParserCONCAT_WS, PostgreSQLParserFORMAT, PostgreSQLParserINITCAP, PostgreSQLParserLENGTH, PostgreSQLParserLPAD, PostgreSQLParserLTRIM, PostgreSQLParserMD5, PostgreSQLParserPARSE_IDENT, PostgreSQLParserPG_CLIENT_ENCODING, PostgreSQLParserQUOTE_IDENT, PostgreSQLParserQUOTE_LITERAL, PostgreSQLParserQUOTE_NULLABLE, PostgreSQLParserREGEXP_COUNT, PostgreSQLParserREGEXP_INSTR, PostgreSQLParserREGEXP_LIKE, PostgreSQLParserREGEXP_MATCH, PostgreSQLParserREGEXP_MATCHES, PostgreSQLParserREGEXP_REPLACE, PostgreSQLParserREGEXP_SPLIT_TO_ARRAY, PostgreSQLParserREGEXP_SPLIT_TO_TABLE, PostgreSQLParserREGEXP_SUBSTR, PostgreSQLParserREPEAT, PostgreSQLParserRPAD, PostgreSQLParserRTRIM, PostgreSQLParserSPLIT_PART, PostgreSQLParserSTARTS_WITH, PostgreSQLParserSTRING_TO_ARRAY, PostgreSQLParserSTRING_TO_TABLE, PostgreSQLParserSTRPOS, PostgreSQLParserSUBSTR, PostgreSQLParserTO_ASCII, PostgreSQLParserTO_HEX, PostgreSQLParserTRANSLATE, PostgreSQLParserUNISTR, PostgreSQLParserAGE, PostgreSQLParserCLOCK_TIMESTAMP, PostgreSQLParserDATE_BIN, PostgreSQLParserDATE_PART, PostgreSQLParserDATE_TRUNC, PostgreSQLParserISFINITE, PostgreSQLParserJUSTIFY_DAYS, PostgreSQLParserJUSTIFY_HOURS, PostgreSQLParserJUSTIFY_INTERVAL, PostgreSQLParserMAKE_DATE, PostgreSQLParserMAKE_INTERVAL, PostgreSQLParserMAKE_TIME, PostgreSQLParserMAKE_TIMESTAMP, PostgreSQLParserMAKE_TIMESTAMPTZ, PostgreSQLParserNOW, PostgreSQLParserSTATEMENT_TIMESTAMP, PostgreSQLParserTIMEOFDAY, PostgreSQLParserTRANSACTION_TIMESTAMP, PostgreSQLParserTO_TIMESTAMP, PostgreSQLParserTO_CHAR, PostgreSQLParserTO_DATE, PostgreSQLParserTO_NUMBER, PostgreSQLParserIdentifier, PostgreSQLParserQuotedIdentifier, PostgreSQLParserUnicodeQuotedIdentifier, PostgreSQLParserStringConstant, PostgreSQLParserUnicodeEscapeStringConstant, PostgreSQLParserBeginDollarStringConstant, PostgreSQLParserPLSQLVARIABLENAME, PostgreSQLParserPLSQLIDENTIFIER, PostgreSQLParserEscapeStringConstant:
		p.EnterOuterAlt(localctx, 4)
		{
			p.SetState(1989)
			p.Nonreservedword_or_sconst()
		}

	default:
		p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IZone_valueContext is an interface to support dynamic dispatch.
type IZone_valueContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Sconst() ISconstContext
	Identifier() IIdentifierContext
	Constinterval() IConstintervalContext
	Opt_interval() IOpt_intervalContext
	OPEN_PAREN() antlr.TerminalNode
	Iconst() IIconstContext
	CLOSE_PAREN() antlr.TerminalNode
	Numericonly() INumericonlyContext
	DEFAULT() antlr.TerminalNode
	LOCAL() antlr.TerminalNode

	// IsZone_valueContext differentiates from other interfaces.
	IsZone_valueContext()
}

type Zone_valueContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyZone_valueContext() *Zone_valueContext {
	var p = new(Zone_valueContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_zone_value
	return p
}

func InitEmptyZone_valueContext(p *Zone_valueContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_zone_value
}

func (*Zone_valueContext) IsZone_valueContext() {}

func NewZone_valueContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Zone_valueContext {
	var p = new(Zone_valueContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_zone_value

	return p
}

func (s *Zone_valueContext) GetParser() antlr.Parser { return s.parser }

func (s *Zone_valueContext) Sconst() ISconstContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ISconstContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ISconstContext)
}

func (s *Zone_valueContext) Identifier() IIdentifierContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IIdentifierContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IIdentifierContext)
}

func (s *Zone_valueContext) Constinterval() IConstintervalContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IConstintervalContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IConstintervalContext)
}

func (s *Zone_valueContext) Opt_interval() IOpt_intervalContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOpt_intervalContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOpt_intervalContext)
}

func (s *Zone_valueContext) OPEN_PAREN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserOPEN_PAREN, 0)
}

func (s *Zone_valueContext) Iconst() IIconstContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IIconstContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IIconstContext)
}

func (s *Zone_valueContext) CLOSE_PAREN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCLOSE_PAREN, 0)
}

func (s *Zone_valueContext) Numericonly() INumericonlyContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(INumericonlyContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(INumericonlyContext)
}

func (s *Zone_valueContext) DEFAULT() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserDEFAULT, 0)
}

func (s *Zone_valueContext) LOCAL() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserLOCAL, 0)
}

func (s *Zone_valueContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Zone_valueContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Zone_valueContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterZone_value(s)
	}
}

func (s *Zone_valueContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitZone_value(s)
	}
}

func (s *Zone_valueContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitZone_value(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Zone_value() (localctx IZone_valueContext) {
	localctx = NewZone_valueContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 68, PostgreSQLParserRULE_zone_value)
	p.SetState(2007)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 26, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(1992)
			p.Sconst()
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(1993)
			p.Identifier()
		}

	case 3:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(1994)
			p.Constinterval()
		}
		{
			p.SetState(1995)
			p.Sconst()
		}
		{
			p.SetState(1996)
			p.Opt_interval()
		}

	case 4:
		p.EnterOuterAlt(localctx, 4)
		{
			p.SetState(1998)
			p.Constinterval()
		}
		{
			p.SetState(1999)
			p.Match(PostgreSQLParserOPEN_PAREN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2000)
			p.Iconst()
		}
		{
			p.SetState(2001)
			p.Match(PostgreSQLParserCLOSE_PAREN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2002)
			p.Sconst()
		}

	case 5:
		p.EnterOuterAlt(localctx, 5)
		{
			p.SetState(2004)
			p.Numericonly()
		}

	case 6:
		p.EnterOuterAlt(localctx, 6)
		{
			p.SetState(2005)
			p.Match(PostgreSQLParserDEFAULT)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 7:
		p.EnterOuterAlt(localctx, 7)
		{
			p.SetState(2006)
			p.Match(PostgreSQLParserLOCAL)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case antlr.ATNInvalidAltNumber:
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IOpt_encodingContext is an interface to support dynamic dispatch.
type IOpt_encodingContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Sconst() ISconstContext
	DEFAULT() antlr.TerminalNode

	// IsOpt_encodingContext differentiates from other interfaces.
	IsOpt_encodingContext()
}

type Opt_encodingContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyOpt_encodingContext() *Opt_encodingContext {
	var p = new(Opt_encodingContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opt_encoding
	return p
}

func InitEmptyOpt_encodingContext(p *Opt_encodingContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opt_encoding
}

func (*Opt_encodingContext) IsOpt_encodingContext() {}

func NewOpt_encodingContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_encodingContext {
	var p = new(Opt_encodingContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_opt_encoding

	return p
}

func (s *Opt_encodingContext) GetParser() antlr.Parser { return s.parser }

func (s *Opt_encodingContext) Sconst() ISconstContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ISconstContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ISconstContext)
}

func (s *Opt_encodingContext) DEFAULT() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserDEFAULT, 0)
}

func (s *Opt_encodingContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Opt_encodingContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Opt_encodingContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterOpt_encoding(s)
	}
}

func (s *Opt_encodingContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitOpt_encoding(s)
	}
}

func (s *Opt_encodingContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitOpt_encoding(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Opt_encoding() (localctx IOpt_encodingContext) {
	localctx = NewOpt_encodingContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 70, PostgreSQLParserRULE_opt_encoding)
	p.SetState(2012)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetTokenStream().LA(1) {
	case PostgreSQLParserStringConstant, PostgreSQLParserUnicodeEscapeStringConstant, PostgreSQLParserBeginDollarStringConstant, PostgreSQLParserEscapeStringConstant:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(2009)
			p.Sconst()
		}

	case PostgreSQLParserDEFAULT:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(2010)
			p.Match(PostgreSQLParserDEFAULT)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case PostgreSQLParserEOF, PostgreSQLParserOPEN_PAREN, PostgreSQLParserSEMI, PostgreSQLParserANALYSE, PostgreSQLParserANALYZE, PostgreSQLParserAS, PostgreSQLParserCREATE, PostgreSQLParserDO, PostgreSQLParserFETCH, PostgreSQLParserGRANT, PostgreSQLParserINTO, PostgreSQLParserNOT, PostgreSQLParserSELECT, PostgreSQLParserTABLE, PostgreSQLParserWINDOW, PostgreSQLParserWITH, PostgreSQLParserABORT_P, PostgreSQLParserALTER, PostgreSQLParserBEGIN_P, PostgreSQLParserCALLED, PostgreSQLParserCHECKPOINT, PostgreSQLParserCLOSE, PostgreSQLParserCLUSTER, PostgreSQLParserCOMMENT, PostgreSQLParserCOMMIT, PostgreSQLParserCOPY, PostgreSQLParserCOST, PostgreSQLParserDEALLOCATE, PostgreSQLParserDECLARE, PostgreSQLParserDELETE_P, PostgreSQLParserDISCARD, PostgreSQLParserDROP, PostgreSQLParserEXECUTE, PostgreSQLParserEXPLAIN, PostgreSQLParserEXTERNAL, PostgreSQLParserIMMUTABLE, PostgreSQLParserINSERT, PostgreSQLParserLANGUAGE, PostgreSQLParserLEAKPROOF, PostgreSQLParserLISTEN, PostgreSQLParserLOAD, PostgreSQLParserLOCK_P, PostgreSQLParserMERGE, PostgreSQLParserMOVE, PostgreSQLParserNOTIFY, PostgreSQLParserPREPARE, PostgreSQLParserREASSIGN, PostgreSQLParserREFRESH, PostgreSQLParserREINDEX, PostgreSQLParserRELEASE, PostgreSQLParserRESET, PostgreSQLParserRESTRICT, PostgreSQLParserRETURNS, PostgreSQLParserREVOKE, PostgreSQLParserROLLBACK, PostgreSQLParserROWS, PostgreSQLParserSAVEPOINT, PostgreSQLParserSECURITY, PostgreSQLParserSET, PostgreSQLParserSHOW, PostgreSQLParserSTABLE, PostgreSQLParserSTART, PostgreSQLParserSTRICT_P, PostgreSQLParserTRUNCATE, PostgreSQLParserUNLISTEN, PostgreSQLParserUPDATE, PostgreSQLParserVACUUM, PostgreSQLParserVOLATILE, PostgreSQLParserVALUES, PostgreSQLParserCALL, PostgreSQLParserTRANSFORM, PostgreSQLParserIMPORT_P, PostgreSQLParserEND_P, PostgreSQLParserSUPPORT, PostgreSQLParserPARALLEL, PostgreSQLParserMetaCommand:
		p.EnterOuterAlt(localctx, 3)

	default:
		p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// INonreservedword_or_sconstContext is an interface to support dynamic dispatch.
type INonreservedword_or_sconstContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Nonreservedword() INonreservedwordContext
	Sconst() ISconstContext

	// IsNonreservedword_or_sconstContext differentiates from other interfaces.
	IsNonreservedword_or_sconstContext()
}

type Nonreservedword_or_sconstContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyNonreservedword_or_sconstContext() *Nonreservedword_or_sconstContext {
	var p = new(Nonreservedword_or_sconstContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_nonreservedword_or_sconst
	return p
}

func InitEmptyNonreservedword_or_sconstContext(p *Nonreservedword_or_sconstContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_nonreservedword_or_sconst
}

func (*Nonreservedword_or_sconstContext) IsNonreservedword_or_sconstContext() {}

func NewNonreservedword_or_sconstContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Nonreservedword_or_sconstContext {
	var p = new(Nonreservedword_or_sconstContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_nonreservedword_or_sconst

	return p
}

func (s *Nonreservedword_or_sconstContext) GetParser() antlr.Parser { return s.parser }

func (s *Nonreservedword_or_sconstContext) Nonreservedword() INonreservedwordContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(INonreservedwordContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(INonreservedwordContext)
}

func (s *Nonreservedword_or_sconstContext) Sconst() ISconstContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ISconstContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ISconstContext)
}

func (s *Nonreservedword_or_sconstContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Nonreservedword_or_sconstContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Nonreservedword_or_sconstContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterNonreservedword_or_sconst(s)
	}
}

func (s *Nonreservedword_or_sconstContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitNonreservedword_or_sconst(s)
	}
}

func (s *Nonreservedword_or_sconstContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitNonreservedword_or_sconst(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Nonreservedword_or_sconst() (localctx INonreservedword_or_sconstContext) {
	localctx = NewNonreservedword_or_sconstContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 72, PostgreSQLParserRULE_nonreservedword_or_sconst)
	p.SetState(2016)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetTokenStream().LA(1) {
	case PostgreSQLParserAND, PostgreSQLParserARRAY, PostgreSQLParserCOLLATE, PostgreSQLParserCOLUMN, PostgreSQLParserCONSTRAINT, PostgreSQLParserDEFAULT, PostgreSQLParserDO, PostgreSQLParserFETCH, PostgreSQLParserTABLE, PostgreSQLParserAUTHORIZATION, PostgreSQLParserBINARY, PostgreSQLParserCOLLATION, PostgreSQLParserCONCURRENTLY, PostgreSQLParserCROSS, PostgreSQLParserCURRENT_SCHEMA, PostgreSQLParserFREEZE, PostgreSQLParserFULL, PostgreSQLParserILIKE, PostgreSQLParserINNER_P, PostgreSQLParserIS, PostgreSQLParserISNULL, PostgreSQLParserJOIN, PostgreSQLParserLIKE, PostgreSQLParserNATURAL, PostgreSQLParserNOTNULL, PostgreSQLParserOUTER_P, PostgreSQLParserOVER, PostgreSQLParserOVERLAPS, PostgreSQLParserSIMILAR, PostgreSQLParserVERBOSE, PostgreSQLParserABORT_P, PostgreSQLParserABSOLUTE_P, PostgreSQLParserACCESS, PostgreSQLParserACTION, PostgreSQLParserADD_P, PostgreSQLParserADMIN, PostgreSQLParserAFTER, PostgreSQLParserAGGREGATE, PostgreSQLParserALSO, PostgreSQLParserALTER, PostgreSQLParserALWAYS, PostgreSQLParserASSERTION, PostgreSQLParserASSIGNMENT, PostgreSQLParserAT, PostgreSQLParserATTRIBUTE, PostgreSQLParserBACKWARD, PostgreSQLParserBEFORE, PostgreSQLParserBEGIN_P, PostgreSQLParserBY, PostgreSQLParserCACHE, PostgreSQLParserCALLED, PostgreSQLParserCASCADE, PostgreSQLParserCASCADED, PostgreSQLParserCATALOG, PostgreSQLParserCHAIN, PostgreSQLParserCHARACTERISTICS, PostgreSQLParserCHECKPOINT, PostgreSQLParserCLASS, PostgreSQLParserCLOSE, PostgreSQLParserCLUSTER, PostgreSQLParserCOMMENT, PostgreSQLParserCOMMENTS, PostgreSQLParserCOMMIT, PostgreSQLParserCOMMITTED, PostgreSQLParserCONFIGURATION, PostgreSQLParserCONNECTION, PostgreSQLParserCONSTRAINTS, PostgreSQLParserCONTENT_P, PostgreSQLParserCONTINUE_P, PostgreSQLParserCONVERSION_P, PostgreSQLParserCOPY, PostgreSQLParserCOST, PostgreSQLParserCSV, PostgreSQLParserCURSOR, PostgreSQLParserCYCLE, PostgreSQLParserDATA_P, PostgreSQLParserDATABASE, PostgreSQLParserDAY_P, PostgreSQLParserDEALLOCATE, PostgreSQLParserDECLARE, PostgreSQLParserDEFAULTS, PostgreSQLParserDEFERRED, PostgreSQLParserDEFINER, PostgreSQLParserDELETE_P, PostgreSQLParserDELIMITER, PostgreSQLParserDELIMITERS, PostgreSQLParserDICTIONARY, PostgreSQLParserDISABLE_P, PostgreSQLParserDISCARD, PostgreSQLParserDOCUMENT_P, PostgreSQLParserDOMAIN_P, PostgreSQLParserDOUBLE_P, PostgreSQLParserDROP, PostgreSQLParserEACH, PostgreSQLParserENABLE_P, PostgreSQLParserENCODING, PostgreSQLParserENCRYPTED, PostgreSQLParserENUM_P, PostgreSQLParserESCAPE, PostgreSQLParserEVENT, PostgreSQLParserEXCLUDE, PostgreSQLParserEXCLUDING, PostgreSQLParserEXCLUSIVE, PostgreSQLParserEXECUTE, PostgreSQLParserEXPLAIN, PostgreSQLParserEXTENSION, PostgreSQLParserEXTERNAL, PostgreSQLParserFAMILY, PostgreSQLParserFIRST_P, PostgreSQLParserFOLLOWING, PostgreSQLParserFORCE, PostgreSQLParserFORWARD, PostgreSQLParserFUNCTION, PostgreSQLParserFUNCTIONS, PostgreSQLParserGLOBAL, PostgreSQLParserGRANTED, PostgreSQLParserHANDLER, PostgreSQLParserHEADER_P, PostgreSQLParserHOLD, PostgreSQLParserHOUR_P, PostgreSQLParserIDENTITY_P, PostgreSQLParserIF_P, PostgreSQLParserIMMEDIATE, PostgreSQLParserIMMUTABLE, PostgreSQLParserIMPLICIT_P, PostgreSQLParserINCLUDING, PostgreSQLParserINCREMENT, PostgreSQLParserINDEX, PostgreSQLParserINDEXES, PostgreSQLParserINHERIT, PostgreSQLParserINHERITS, PostgreSQLParserINLINE_P, PostgreSQLParserINSENSITIVE, PostgreSQLParserINSERT, PostgreSQLParserINSTEAD, PostgreSQLParserINVOKER, PostgreSQLParserISOLATION, PostgreSQLParserKEY, PostgreSQLParserLABEL, PostgreSQLParserLANGUAGE, PostgreSQLParserLARGE_P, PostgreSQLParserLAST_P, PostgreSQLParserLEAKPROOF, PostgreSQLParserLEVEL, PostgreSQLParserLISTEN, PostgreSQLParserLOAD, PostgreSQLParserLOCAL, PostgreSQLParserLOCATION, PostgreSQLParserLOCK_P, PostgreSQLParserMAPPING, PostgreSQLParserMATCH, PostgreSQLParserMATERIALIZED, PostgreSQLParserMAXVALUE, PostgreSQLParserMINUTE_P, PostgreSQLParserMINVALUE, PostgreSQLParserMODE, PostgreSQLParserMONTH_P, PostgreSQLParserMOVE, PostgreSQLParserNAME_P, PostgreSQLParserNAMES, PostgreSQLParserNEXT, PostgreSQLParserNO, PostgreSQLParserNOTHING, PostgreSQLParserNOTIFY, PostgreSQLParserNOWAIT, PostgreSQLParserNULLS_P, PostgreSQLParserOBJECT_P, PostgreSQLParserOF, PostgreSQLParserOFF, PostgreSQLParserOIDS, PostgreSQLParserOPERATOR, PostgreSQLParserOPTION, PostgreSQLParserOPTIONS, PostgreSQLParserOWNED, PostgreSQLParserOWNER, PostgreSQLParserPARSER, PostgreSQLParserPARTIAL, PostgreSQLParserPARTITION, PostgreSQLParserPASSING, PostgreSQLParserPASSWORD, PostgreSQLParserPLANS, PostgreSQLParserPRECEDING, PostgreSQLParserPREPARE, PostgreSQLParserPREPARED, PostgreSQLParserPRESERVE, PostgreSQLParserPRIOR, PostgreSQLParserPRIVILEGES, PostgreSQLParserPROCEDURAL, PostgreSQLParserPROCEDURE, PostgreSQLParserPROGRAM, PostgreSQLParserQUOTE, PostgreSQLParserRANGE, PostgreSQLParserREAD, PostgreSQLParserREASSIGN, PostgreSQLParserRECHECK, PostgreSQLParserRECURSIVE, PostgreSQLParserREF, PostgreSQLParserREFRESH, PostgreSQLParserREINDEX, PostgreSQLParserRELATIVE_P, PostgreSQLParserRELEASE, PostgreSQLParserRENAME, PostgreSQLParserREPEATABLE, PostgreSQLParserREPLACE, PostgreSQLParserREPLICA, PostgreSQLParserRESET, PostgreSQLParserRESTART, PostgreSQLParserRESTRICT, PostgreSQLParserRETURNS, PostgreSQLParserREVOKE, PostgreSQLParserROLE, PostgreSQLParserROLLBACK, PostgreSQLParserROWS, PostgreSQLParserRULE, PostgreSQLParserSAVEPOINT, PostgreSQLParserSCHEMA, PostgreSQLParserSCROLL, PostgreSQLParserSEARCH, PostgreSQLParserSECOND_P, PostgreSQLParserSECURITY, PostgreSQLParserSEQUENCE, PostgreSQLParserSEQUENCES, PostgreSQLParserSERIALIZABLE, PostgreSQLParserSERVER, PostgreSQLParserSESSION, PostgreSQLParserSET, PostgreSQLParserSHARE, PostgreSQLParserSHOW, PostgreSQLParserSIMPLE, PostgreSQLParserSNAPSHOT, PostgreSQLParserSTABLE, PostgreSQLParserSTANDALONE_P, PostgreSQLParserSTART, PostgreSQLParserSTATEMENT, PostgreSQLParserSTATISTICS, PostgreSQLParserSTDIN, PostgreSQLParserSTDOUT, PostgreSQLParserSTORAGE, PostgreSQLParserSTRICT_P, PostgreSQLParserSTRIP_P, PostgreSQLParserSYSID, PostgreSQLParserSYSTEM_P, PostgreSQLParserTABLES, PostgreSQLParserTABLESPACE, PostgreSQLParserTEMP, PostgreSQLParserTEMPLATE, PostgreSQLParserTEMPORARY, PostgreSQLParserTEXT_P, PostgreSQLParserTRANSACTION, PostgreSQLParserTRIGGER, PostgreSQLParserTRUNCATE, PostgreSQLParserTRUSTED, PostgreSQLParserTYPE_P, PostgreSQLParserTYPES_P, PostgreSQLParserUNBOUNDED, PostgreSQLParserUNCOMMITTED, PostgreSQLParserUNENCRYPTED, PostgreSQLParserUNKNOWN, PostgreSQLParserUNLISTEN, PostgreSQLParserUNLOGGED, PostgreSQLParserUNTIL, PostgreSQLParserUPDATE, PostgreSQLParserVACUUM, PostgreSQLParserVALID, PostgreSQLParserVALIDATE, PostgreSQLParserVALIDATOR, PostgreSQLParserVARYING, PostgreSQLParserVERSION_P, PostgreSQLParserVIEW, PostgreSQLParserVOLATILE, PostgreSQLParserWHITESPACE_P, PostgreSQLParserWITHOUT, PostgreSQLParserWORK, PostgreSQLParserWRAPPER, PostgreSQLParserWRITE, PostgreSQLParserXML_P, PostgreSQLParserYEAR_P, PostgreSQLParserYES_P, PostgreSQLParserZONE, PostgreSQLParserBETWEEN, PostgreSQLParserBIGINT, PostgreSQLParserBIT, PostgreSQLParserBOOLEAN_P, PostgreSQLParserCHAR_P, PostgreSQLParserCHARACTER, PostgreSQLParserCOALESCE, PostgreSQLParserDEC, PostgreSQLParserDECIMAL_P, PostgreSQLParserEXISTS, PostgreSQLParserEXTRACT, PostgreSQLParserFLOAT_P, PostgreSQLParserGREATEST, PostgreSQLParserINOUT, PostgreSQLParserINT_P, PostgreSQLParserINTEGER, PostgreSQLParserINTERVAL, PostgreSQLParserLEAST, PostgreSQLParserNATIONAL, PostgreSQLParserNCHAR, PostgreSQLParserNONE, PostgreSQLParserNULLIF, PostgreSQLParserNUMERIC, PostgreSQLParserOVERLAY, PostgreSQLParserPOSITION, PostgreSQLParserPRECISION, PostgreSQLParserREAL, PostgreSQLParserROW, PostgreSQLParserSETOF, PostgreSQLParserSMALLINT, PostgreSQLParserSUBSTRING, PostgreSQLParserTIME, PostgreSQLParserTIMESTAMP, PostgreSQLParserTREAT, PostgreSQLParserTRIM, PostgreSQLParserVALUES, PostgreSQLParserVARCHAR, PostgreSQLParserXMLATTRIBUTES, PostgreSQLParserXMLCOMMENT, PostgreSQLParserXMLAGG, PostgreSQLParserXML_IS_WELL_FORMED, PostgreSQLParserXML_IS_WELL_FORMED_DOCUMENT, PostgreSQLParserXML_IS_WELL_FORMED_CONTENT, PostgreSQLParserXPATH, PostgreSQLParserXPATH_EXISTS, PostgreSQLParserXMLCONCAT, PostgreSQLParserXMLELEMENT, PostgreSQLParserXMLEXISTS, PostgreSQLParserXMLFOREST, PostgreSQLParserXMLPARSE, PostgreSQLParserXMLPI, PostgreSQLParserXMLROOT, PostgreSQLParserXMLSERIALIZE, PostgreSQLParserCALL, PostgreSQLParserCURRENT_P, PostgreSQLParserATTACH, PostgreSQLParserDETACH, PostgreSQLParserEXPRESSION, PostgreSQLParserGENERATED, PostgreSQLParserLOGGED, PostgreSQLParserSTORED, PostgreSQLParserINCLUDE, PostgreSQLParserROUTINE, PostgreSQLParserTRANSFORM, PostgreSQLParserIMPORT_P, PostgreSQLParserPOLICY, PostgreSQLParserMETHOD, PostgreSQLParserREFERENCING, PostgreSQLParserNEW, PostgreSQLParserOLD, PostgreSQLParserVALUE_P, PostgreSQLParserSUBSCRIPTION, PostgreSQLParserPUBLICATION, PostgreSQLParserOUT_P, PostgreSQLParserROUTINES, PostgreSQLParserSCHEMAS, PostgreSQLParserPROCEDURES, PostgreSQLParserINPUT_P, PostgreSQLParserSUPPORT, PostgreSQLParserPARALLEL, PostgreSQLParserSQL_P, PostgreSQLParserDEPENDS, PostgreSQLParserOVERRIDING, PostgreSQLParserCONFLICT, PostgreSQLParserSKIP_P, PostgreSQLParserLOCKED, PostgreSQLParserTIES, PostgreSQLParserROLLUP, PostgreSQLParserCUBE, PostgreSQLParserGROUPING, PostgreSQLParserSETS, PostgreSQLParserTABLESAMPLE, PostgreSQLParserORDINALITY, PostgreSQLParserXMLTABLE, PostgreSQLParserCOLUMNS, PostgreSQLParserXMLNAMESPACES, PostgreSQLParserROWTYPE, PostgreSQLParserNORMALIZED, PostgreSQLParserWITHIN, PostgreSQLParserFILTER, PostgreSQLParserGROUPS, PostgreSQLParserOTHERS, PostgreSQLParserNFC, PostgreSQLParserNFD, PostgreSQLParserNFKC, PostgreSQLParserNFKD, PostgreSQLParserUESCAPE, PostgreSQLParserVIEWS, PostgreSQLParserNORMALIZE, PostgreSQLParserDUMP, PostgreSQLParserPRINT_STRICT_PARAMS, PostgreSQLParserVARIABLE_CONFLICT, PostgreSQLParserERROR, PostgreSQLParserUSE_VARIABLE, PostgreSQLParserUSE_COLUMN, PostgreSQLParserALIAS, PostgreSQLParserCONSTANT, PostgreSQLParserPERFORM, PostgreSQLParserGET, PostgreSQLParserDIAGNOSTICS, PostgreSQLParserSTACKED, PostgreSQLParserELSIF, PostgreSQLParserREVERSE, PostgreSQLParserSLICE, PostgreSQLParserEXIT, PostgreSQLParserRETURN, PostgreSQLParserQUERY, PostgreSQLParserRAISE, PostgreSQLParserSQLSTATE, PostgreSQLParserDEBUG, PostgreSQLParserLOG, PostgreSQLParserINFO, PostgreSQLParserNOTICE, PostgreSQLParserWARNING, PostgreSQLParserEXCEPTION, PostgreSQLParserASSERT, PostgreSQLParserOPEN, PostgreSQLParserABS, PostgreSQLParserCBRT, PostgreSQLParserCEIL, PostgreSQLParserCEILING, PostgreSQLParserDEGREES, PostgreSQLParserDIV, PostgreSQLParserEXP, PostgreSQLParserFACTORIAL, PostgreSQLParserFLOOR, PostgreSQLParserGCD, PostgreSQLParserLCM, PostgreSQLParserLN, PostgreSQLParserLOG10, PostgreSQLParserMIN_SCALE, PostgreSQLParserMOD, PostgreSQLParserPI, PostgreSQLParserPOWER, PostgreSQLParserRADIANS, PostgreSQLParserROUND, PostgreSQLParserSCALE, PostgreSQLParserSIGN, PostgreSQLParserSQRT, PostgreSQLParserTRIM_SCALE, PostgreSQLParserTRUNC, PostgreSQLParserWIDTH_BUCKET, PostgreSQLParserRANDOM, PostgreSQLParserSETSEED, PostgreSQLParserACOS, PostgreSQLParserACOSD, PostgreSQLParserASIN, PostgreSQLParserASIND, PostgreSQLParserATAN, PostgreSQLParserATAND, PostgreSQLParserATAN2, PostgreSQLParserATAN2D, PostgreSQLParserCOS, PostgreSQLParserCOSD, PostgreSQLParserCOT, PostgreSQLParserCOTD, PostgreSQLParserSIN, PostgreSQLParserSIND, PostgreSQLParserTAN, PostgreSQLParserTAND, PostgreSQLParserSINH, PostgreSQLParserCOSH, PostgreSQLParserTANH, PostgreSQLParserASINH, PostgreSQLParserACOSH, PostgreSQLParserATANH, PostgreSQLParserBIT_LENGTH, PostgreSQLParserCHAR_LENGTH, PostgreSQLParserCHARACTER_LENGTH, PostgreSQLParserLOWER, PostgreSQLParserOCTET_LENGTH, PostgreSQLParserUPPER, PostgreSQLParserASCII, PostgreSQLParserBTRIM, PostgreSQLParserCHR, PostgreSQLParserCONCAT, PostgreSQLParserCONCAT_WS, PostgreSQLParserFORMAT, PostgreSQLParserINITCAP, PostgreSQLParserLENGTH, PostgreSQLParserLPAD, PostgreSQLParserLTRIM, PostgreSQLParserMD5, PostgreSQLParserPARSE_IDENT, PostgreSQLParserPG_CLIENT_ENCODING, PostgreSQLParserQUOTE_IDENT, PostgreSQLParserQUOTE_LITERAL, PostgreSQLParserQUOTE_NULLABLE, PostgreSQLParserREGEXP_COUNT, PostgreSQLParserREGEXP_INSTR, PostgreSQLParserREGEXP_LIKE, PostgreSQLParserREGEXP_MATCH, PostgreSQLParserREGEXP_MATCHES, PostgreSQLParserREGEXP_REPLACE, PostgreSQLParserREGEXP_SPLIT_TO_ARRAY, PostgreSQLParserREGEXP_SPLIT_TO_TABLE, PostgreSQLParserREGEXP_SUBSTR, PostgreSQLParserREPEAT, PostgreSQLParserRPAD, PostgreSQLParserRTRIM, PostgreSQLParserSPLIT_PART, PostgreSQLParserSTARTS_WITH, PostgreSQLParserSTRING_TO_ARRAY, PostgreSQLParserSTRING_TO_TABLE, PostgreSQLParserSTRPOS, PostgreSQLParserSUBSTR, PostgreSQLParserTO_ASCII, PostgreSQLParserTO_HEX, PostgreSQLParserTRANSLATE, PostgreSQLParserUNISTR, PostgreSQLParserAGE, PostgreSQLParserCLOCK_TIMESTAMP, PostgreSQLParserDATE_BIN, PostgreSQLParserDATE_PART, PostgreSQLParserDATE_TRUNC, PostgreSQLParserISFINITE, PostgreSQLParserJUSTIFY_DAYS, PostgreSQLParserJUSTIFY_HOURS, PostgreSQLParserJUSTIFY_INTERVAL, PostgreSQLParserMAKE_DATE, PostgreSQLParserMAKE_INTERVAL, PostgreSQLParserMAKE_TIME, PostgreSQLParserMAKE_TIMESTAMP, PostgreSQLParserMAKE_TIMESTAMPTZ, PostgreSQLParserNOW, PostgreSQLParserSTATEMENT_TIMESTAMP, PostgreSQLParserTIMEOFDAY, PostgreSQLParserTRANSACTION_TIMESTAMP, PostgreSQLParserTO_TIMESTAMP, PostgreSQLParserTO_CHAR, PostgreSQLParserTO_DATE, PostgreSQLParserTO_NUMBER, PostgreSQLParserIdentifier, PostgreSQLParserQuotedIdentifier, PostgreSQLParserUnicodeQuotedIdentifier, PostgreSQLParserPLSQLVARIABLENAME, PostgreSQLParserPLSQLIDENTIFIER:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(2014)
			p.Nonreservedword()
		}

	case PostgreSQLParserStringConstant, PostgreSQLParserUnicodeEscapeStringConstant, PostgreSQLParserBeginDollarStringConstant, PostgreSQLParserEscapeStringConstant:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(2015)
			p.Sconst()
		}

	default:
		p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IVariableresetstmtContext is an interface to support dynamic dispatch.
type IVariableresetstmtContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	RESET() antlr.TerminalNode
	Reset_rest() IReset_restContext

	// IsVariableresetstmtContext differentiates from other interfaces.
	IsVariableresetstmtContext()
}

type VariableresetstmtContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyVariableresetstmtContext() *VariableresetstmtContext {
	var p = new(VariableresetstmtContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_variableresetstmt
	return p
}

func InitEmptyVariableresetstmtContext(p *VariableresetstmtContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_variableresetstmt
}

func (*VariableresetstmtContext) IsVariableresetstmtContext() {}

func NewVariableresetstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *VariableresetstmtContext {
	var p = new(VariableresetstmtContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_variableresetstmt

	return p
}

func (s *VariableresetstmtContext) GetParser() antlr.Parser { return s.parser }

func (s *VariableresetstmtContext) RESET() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserRESET, 0)
}

func (s *VariableresetstmtContext) Reset_rest() IReset_restContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IReset_restContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IReset_restContext)
}

func (s *VariableresetstmtContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *VariableresetstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *VariableresetstmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterVariableresetstmt(s)
	}
}

func (s *VariableresetstmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitVariableresetstmt(s)
	}
}

func (s *VariableresetstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitVariableresetstmt(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Variableresetstmt() (localctx IVariableresetstmtContext) {
	localctx = NewVariableresetstmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 74, PostgreSQLParserRULE_variableresetstmt)
	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(2018)
		p.Match(PostgreSQLParserRESET)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(2019)
		p.Reset_rest()
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IReset_restContext is an interface to support dynamic dispatch.
type IReset_restContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Generic_reset() IGeneric_resetContext
	TIME() antlr.TerminalNode
	ZONE() antlr.TerminalNode
	TRANSACTION() antlr.TerminalNode
	ISOLATION() antlr.TerminalNode
	LEVEL() antlr.TerminalNode
	SESSION() antlr.TerminalNode
	AUTHORIZATION() antlr.TerminalNode

	// IsReset_restContext differentiates from other interfaces.
	IsReset_restContext()
}

type Reset_restContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyReset_restContext() *Reset_restContext {
	var p = new(Reset_restContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_reset_rest
	return p
}

func InitEmptyReset_restContext(p *Reset_restContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_reset_rest
}

func (*Reset_restContext) IsReset_restContext() {}

func NewReset_restContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Reset_restContext {
	var p = new(Reset_restContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_reset_rest

	return p
}

func (s *Reset_restContext) GetParser() antlr.Parser { return s.parser }

func (s *Reset_restContext) Generic_reset() IGeneric_resetContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IGeneric_resetContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IGeneric_resetContext)
}

func (s *Reset_restContext) TIME() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserTIME, 0)
}

func (s *Reset_restContext) ZONE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserZONE, 0)
}

func (s *Reset_restContext) TRANSACTION() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserTRANSACTION, 0)
}

func (s *Reset_restContext) ISOLATION() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserISOLATION, 0)
}

func (s *Reset_restContext) LEVEL() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserLEVEL, 0)
}

func (s *Reset_restContext) SESSION() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserSESSION, 0)
}

func (s *Reset_restContext) AUTHORIZATION() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserAUTHORIZATION, 0)
}

func (s *Reset_restContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Reset_restContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Reset_restContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterReset_rest(s)
	}
}

func (s *Reset_restContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitReset_rest(s)
	}
}

func (s *Reset_restContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitReset_rest(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Reset_rest() (localctx IReset_restContext) {
	localctx = NewReset_restContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 76, PostgreSQLParserRULE_reset_rest)
	p.SetState(2029)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 29, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(2021)
			p.Generic_reset()
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(2022)
			p.Match(PostgreSQLParserTIME)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2023)
			p.Match(PostgreSQLParserZONE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 3:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(2024)
			p.Match(PostgreSQLParserTRANSACTION)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2025)
			p.Match(PostgreSQLParserISOLATION)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2026)
			p.Match(PostgreSQLParserLEVEL)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 4:
		p.EnterOuterAlt(localctx, 4)
		{
			p.SetState(2027)
			p.Match(PostgreSQLParserSESSION)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2028)
			p.Match(PostgreSQLParserAUTHORIZATION)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case antlr.ATNInvalidAltNumber:
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IGeneric_resetContext is an interface to support dynamic dispatch.
type IGeneric_resetContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Var_name() IVar_nameContext
	ALL() antlr.TerminalNode

	// IsGeneric_resetContext differentiates from other interfaces.
	IsGeneric_resetContext()
}

type Generic_resetContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyGeneric_resetContext() *Generic_resetContext {
	var p = new(Generic_resetContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_generic_reset
	return p
}

func InitEmptyGeneric_resetContext(p *Generic_resetContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_generic_reset
}

func (*Generic_resetContext) IsGeneric_resetContext() {}

func NewGeneric_resetContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Generic_resetContext {
	var p = new(Generic_resetContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_generic_reset

	return p
}

func (s *Generic_resetContext) GetParser() antlr.Parser { return s.parser }

func (s *Generic_resetContext) Var_name() IVar_nameContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IVar_nameContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IVar_nameContext)
}

func (s *Generic_resetContext) ALL() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserALL, 0)
}

func (s *Generic_resetContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Generic_resetContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Generic_resetContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterGeneric_reset(s)
	}
}

func (s *Generic_resetContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitGeneric_reset(s)
	}
}

func (s *Generic_resetContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitGeneric_reset(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Generic_reset() (localctx IGeneric_resetContext) {
	localctx = NewGeneric_resetContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 78, PostgreSQLParserRULE_generic_reset)
	p.SetState(2033)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetTokenStream().LA(1) {
	case PostgreSQLParserAND, PostgreSQLParserARRAY, PostgreSQLParserCOLLATE, PostgreSQLParserCOLUMN, PostgreSQLParserCONSTRAINT, PostgreSQLParserDEFAULT, PostgreSQLParserDO, PostgreSQLParserFETCH, PostgreSQLParserTABLE, PostgreSQLParserIS, PostgreSQLParserLEFT, PostgreSQLParserOUTER_P, PostgreSQLParserOVER, PostgreSQLParserRIGHT, PostgreSQLParserABORT_P, PostgreSQLParserABSOLUTE_P, PostgreSQLParserACCESS, PostgreSQLParserACTION, PostgreSQLParserADD_P, PostgreSQLParserADMIN, PostgreSQLParserAFTER, PostgreSQLParserAGGREGATE, PostgreSQLParserALSO, PostgreSQLParserALTER, PostgreSQLParserALWAYS, PostgreSQLParserASSERTION, PostgreSQLParserASSIGNMENT, PostgreSQLParserAT, PostgreSQLParserATTRIBUTE, PostgreSQLParserBACKWARD, PostgreSQLParserBEFORE, PostgreSQLParserBEGIN_P, PostgreSQLParserBY, PostgreSQLParserCACHE, PostgreSQLParserCALLED, PostgreSQLParserCASCADE, PostgreSQLParserCASCADED, PostgreSQLParserCATALOG, PostgreSQLParserCHAIN, PostgreSQLParserCHARACTERISTICS, PostgreSQLParserCHECKPOINT, PostgreSQLParserCLASS, PostgreSQLParserCLOSE, PostgreSQLParserCLUSTER, PostgreSQLParserCOMMENT, PostgreSQLParserCOMMENTS, PostgreSQLParserCOMMIT, PostgreSQLParserCOMMITTED, PostgreSQLParserCONFIGURATION, PostgreSQLParserCONNECTION, PostgreSQLParserCONSTRAINTS, PostgreSQLParserCONTENT_P, PostgreSQLParserCONTINUE_P, PostgreSQLParserCONVERSION_P, PostgreSQLParserCOPY, PostgreSQLParserCOST, PostgreSQLParserCSV, PostgreSQLParserCURSOR, PostgreSQLParserCYCLE, PostgreSQLParserDATA_P, PostgreSQLParserDATABASE, PostgreSQLParserDAY_P, PostgreSQLParserDEALLOCATE, PostgreSQLParserDECLARE, PostgreSQLParserDEFAULTS, PostgreSQLParserDEFERRED, PostgreSQLParserDEFINER, PostgreSQLParserDELETE_P, PostgreSQLParserDELIMITER, PostgreSQLParserDELIMITERS, PostgreSQLParserDICTIONARY, PostgreSQLParserDISABLE_P, PostgreSQLParserDISCARD, PostgreSQLParserDOCUMENT_P, PostgreSQLParserDOMAIN_P, PostgreSQLParserDOUBLE_P, PostgreSQLParserDROP, PostgreSQLParserEACH, PostgreSQLParserENABLE_P, PostgreSQLParserENCODING, PostgreSQLParserENCRYPTED, PostgreSQLParserENUM_P, PostgreSQLParserESCAPE, PostgreSQLParserEVENT, PostgreSQLParserEXCLUDE, PostgreSQLParserEXCLUDING, PostgreSQLParserEXCLUSIVE, PostgreSQLParserEXECUTE, PostgreSQLParserEXPLAIN, PostgreSQLParserEXTENSION, PostgreSQLParserEXTERNAL, PostgreSQLParserFAMILY, PostgreSQLParserFIRST_P, PostgreSQLParserFOLLOWING, PostgreSQLParserFORCE, PostgreSQLParserFORWARD, PostgreSQLParserFUNCTION, PostgreSQLParserFUNCTIONS, PostgreSQLParserGLOBAL, PostgreSQLParserGRANTED, PostgreSQLParserHANDLER, PostgreSQLParserHEADER_P, PostgreSQLParserHOLD, PostgreSQLParserHOUR_P, PostgreSQLParserIDENTITY_P, PostgreSQLParserIF_P, PostgreSQLParserIMMEDIATE, PostgreSQLParserIMMUTABLE, PostgreSQLParserIMPLICIT_P, PostgreSQLParserINCLUDING, PostgreSQLParserINCREMENT, PostgreSQLParserINDEX, PostgreSQLParserINDEXES, PostgreSQLParserINHERIT, PostgreSQLParserINHERITS, PostgreSQLParserINLINE_P, PostgreSQLParserINSENSITIVE, PostgreSQLParserINSERT, PostgreSQLParserINSTEAD, PostgreSQLParserINVOKER, PostgreSQLParserISOLATION, PostgreSQLParserKEY, PostgreSQLParserLABEL, PostgreSQLParserLANGUAGE, PostgreSQLParserLARGE_P, PostgreSQLParserLAST_P, PostgreSQLParserLEAKPROOF, PostgreSQLParserLEVEL, PostgreSQLParserLISTEN, PostgreSQLParserLOAD, PostgreSQLParserLOCAL, PostgreSQLParserLOCATION, PostgreSQLParserLOCK_P, PostgreSQLParserMAPPING, PostgreSQLParserMATCH, PostgreSQLParserMATERIALIZED, PostgreSQLParserMAXVALUE, PostgreSQLParserMINUTE_P, PostgreSQLParserMINVALUE, PostgreSQLParserMODE, PostgreSQLParserMONTH_P, PostgreSQLParserMOVE, PostgreSQLParserNAME_P, PostgreSQLParserNAMES, PostgreSQLParserNEXT, PostgreSQLParserNO, PostgreSQLParserNOTHING, PostgreSQLParserNOTIFY, PostgreSQLParserNOWAIT, PostgreSQLParserNULLS_P, PostgreSQLParserOBJECT_P, PostgreSQLParserOF, PostgreSQLParserOFF, PostgreSQLParserOIDS, PostgreSQLParserOPERATOR, PostgreSQLParserOPTION, PostgreSQLParserOPTIONS, PostgreSQLParserOWNED, PostgreSQLParserOWNER, PostgreSQLParserPARSER, PostgreSQLParserPARTIAL, PostgreSQLParserPARTITION, PostgreSQLParserPASSING, PostgreSQLParserPASSWORD, PostgreSQLParserPLANS, PostgreSQLParserPRECEDING, PostgreSQLParserPREPARE, PostgreSQLParserPREPARED, PostgreSQLParserPRESERVE, PostgreSQLParserPRIOR, PostgreSQLParserPRIVILEGES, PostgreSQLParserPROCEDURAL, PostgreSQLParserPROCEDURE, PostgreSQLParserPROGRAM, PostgreSQLParserQUOTE, PostgreSQLParserRANGE, PostgreSQLParserREAD, PostgreSQLParserREASSIGN, PostgreSQLParserRECHECK, PostgreSQLParserRECURSIVE, PostgreSQLParserREF, PostgreSQLParserREFRESH, PostgreSQLParserREINDEX, PostgreSQLParserRELATIVE_P, PostgreSQLParserRELEASE, PostgreSQLParserRENAME, PostgreSQLParserREPEATABLE, PostgreSQLParserREPLACE, PostgreSQLParserREPLICA, PostgreSQLParserRESET, PostgreSQLParserRESTART, PostgreSQLParserRESTRICT, PostgreSQLParserRETURNS, PostgreSQLParserREVOKE, PostgreSQLParserROLE, PostgreSQLParserROLLBACK, PostgreSQLParserROWS, PostgreSQLParserRULE, PostgreSQLParserSAVEPOINT, PostgreSQLParserSCHEMA, PostgreSQLParserSCROLL, PostgreSQLParserSEARCH, PostgreSQLParserSECOND_P, PostgreSQLParserSECURITY, PostgreSQLParserSEQUENCE, PostgreSQLParserSEQUENCES, PostgreSQLParserSERIALIZABLE, PostgreSQLParserSERVER, PostgreSQLParserSESSION, PostgreSQLParserSET, PostgreSQLParserSHARE, PostgreSQLParserSHOW, PostgreSQLParserSIMPLE, PostgreSQLParserSNAPSHOT, PostgreSQLParserSTABLE, PostgreSQLParserSTANDALONE_P, PostgreSQLParserSTART, PostgreSQLParserSTATEMENT, PostgreSQLParserSTATISTICS, PostgreSQLParserSTDIN, PostgreSQLParserSTDOUT, PostgreSQLParserSTORAGE, PostgreSQLParserSTRICT_P, PostgreSQLParserSTRIP_P, PostgreSQLParserSYSID, PostgreSQLParserSYSTEM_P, PostgreSQLParserTABLES, PostgreSQLParserTABLESPACE, PostgreSQLParserTEMP, PostgreSQLParserTEMPLATE, PostgreSQLParserTEMPORARY, PostgreSQLParserTEXT_P, PostgreSQLParserTRANSACTION, PostgreSQLParserTRIGGER, PostgreSQLParserTRUNCATE, PostgreSQLParserTRUSTED, PostgreSQLParserTYPE_P, PostgreSQLParserTYPES_P, PostgreSQLParserUNBOUNDED, PostgreSQLParserUNCOMMITTED, PostgreSQLParserUNENCRYPTED, PostgreSQLParserUNKNOWN, PostgreSQLParserUNLISTEN, PostgreSQLParserUNLOGGED, PostgreSQLParserUNTIL, PostgreSQLParserUPDATE, PostgreSQLParserVACUUM, PostgreSQLParserVALID, PostgreSQLParserVALIDATE, PostgreSQLParserVALIDATOR, PostgreSQLParserVARYING, PostgreSQLParserVERSION_P, PostgreSQLParserVIEW, PostgreSQLParserVOLATILE, PostgreSQLParserWHITESPACE_P, PostgreSQLParserWITHOUT, PostgreSQLParserWORK, PostgreSQLParserWRAPPER, PostgreSQLParserWRITE, PostgreSQLParserXML_P, PostgreSQLParserYEAR_P, PostgreSQLParserYES_P, PostgreSQLParserZONE, PostgreSQLParserBETWEEN, PostgreSQLParserBIGINT, PostgreSQLParserBIT, PostgreSQLParserBOOLEAN_P, PostgreSQLParserCHAR_P, PostgreSQLParserCHARACTER, PostgreSQLParserCOALESCE, PostgreSQLParserDEC, PostgreSQLParserDECIMAL_P, PostgreSQLParserEXISTS, PostgreSQLParserEXTRACT, PostgreSQLParserFLOAT_P, PostgreSQLParserGREATEST, PostgreSQLParserINOUT, PostgreSQLParserINT_P, PostgreSQLParserINTEGER, PostgreSQLParserINTERVAL, PostgreSQLParserLEAST, PostgreSQLParserNATIONAL, PostgreSQLParserNCHAR, PostgreSQLParserNONE, PostgreSQLParserNULLIF, PostgreSQLParserNUMERIC, PostgreSQLParserOVERLAY, PostgreSQLParserPOSITION, PostgreSQLParserPRECISION, PostgreSQLParserREAL, PostgreSQLParserROW, PostgreSQLParserSETOF, PostgreSQLParserSMALLINT, PostgreSQLParserSUBSTRING, PostgreSQLParserTIME, PostgreSQLParserTIMESTAMP, PostgreSQLParserTREAT, PostgreSQLParserTRIM, PostgreSQLParserVALUES, PostgreSQLParserVARCHAR, PostgreSQLParserXMLATTRIBUTES, PostgreSQLParserXMLCOMMENT, PostgreSQLParserXMLAGG, PostgreSQLParserXML_IS_WELL_FORMED, PostgreSQLParserXML_IS_WELL_FORMED_DOCUMENT, PostgreSQLParserXML_IS_WELL_FORMED_CONTENT, PostgreSQLParserXPATH, PostgreSQLParserXPATH_EXISTS, PostgreSQLParserXMLCONCAT, PostgreSQLParserXMLELEMENT, PostgreSQLParserXMLEXISTS, PostgreSQLParserXMLFOREST, PostgreSQLParserXMLPARSE, PostgreSQLParserXMLPI, PostgreSQLParserXMLROOT, PostgreSQLParserXMLSERIALIZE, PostgreSQLParserCALL, PostgreSQLParserCURRENT_P, PostgreSQLParserATTACH, PostgreSQLParserDETACH, PostgreSQLParserEXPRESSION, PostgreSQLParserGENERATED, PostgreSQLParserLOGGED, PostgreSQLParserSTORED, PostgreSQLParserINCLUDE, PostgreSQLParserROUTINE, PostgreSQLParserTRANSFORM, PostgreSQLParserIMPORT_P, PostgreSQLParserPOLICY, PostgreSQLParserMETHOD, PostgreSQLParserREFERENCING, PostgreSQLParserNEW, PostgreSQLParserOLD, PostgreSQLParserVALUE_P, PostgreSQLParserSUBSCRIPTION, PostgreSQLParserPUBLICATION, PostgreSQLParserOUT_P, PostgreSQLParserROUTINES, PostgreSQLParserSCHEMAS, PostgreSQLParserPROCEDURES, PostgreSQLParserINPUT_P, PostgreSQLParserSUPPORT, PostgreSQLParserPARALLEL, PostgreSQLParserSQL_P, PostgreSQLParserDEPENDS, PostgreSQLParserOVERRIDING, PostgreSQLParserCONFLICT, PostgreSQLParserSKIP_P, PostgreSQLParserLOCKED, PostgreSQLParserTIES, PostgreSQLParserROLLUP, PostgreSQLParserCUBE, PostgreSQLParserGROUPING, PostgreSQLParserSETS, PostgreSQLParserORDINALITY, PostgreSQLParserXMLTABLE, PostgreSQLParserCOLUMNS, PostgreSQLParserXMLNAMESPACES, PostgreSQLParserROWTYPE, PostgreSQLParserNORMALIZED, PostgreSQLParserWITHIN, PostgreSQLParserFILTER, PostgreSQLParserGROUPS, PostgreSQLParserOTHERS, PostgreSQLParserNFC, PostgreSQLParserNFD, PostgreSQLParserNFKC, PostgreSQLParserNFKD, PostgreSQLParserUESCAPE, PostgreSQLParserVIEWS, PostgreSQLParserNORMALIZE, PostgreSQLParserDUMP, PostgreSQLParserPRINT_STRICT_PARAMS, PostgreSQLParserVARIABLE_CONFLICT, PostgreSQLParserERROR, PostgreSQLParserUSE_VARIABLE, PostgreSQLParserUSE_COLUMN, PostgreSQLParserALIAS, PostgreSQLParserCONSTANT, PostgreSQLParserPERFORM, PostgreSQLParserGET, PostgreSQLParserDIAGNOSTICS, PostgreSQLParserSTACKED, PostgreSQLParserELSIF, PostgreSQLParserREVERSE, PostgreSQLParserSLICE, PostgreSQLParserEXIT, PostgreSQLParserRETURN, PostgreSQLParserQUERY, PostgreSQLParserRAISE, PostgreSQLParserSQLSTATE, PostgreSQLParserDEBUG, PostgreSQLParserLOG, PostgreSQLParserINFO, PostgreSQLParserNOTICE, PostgreSQLParserWARNING, PostgreSQLParserEXCEPTION, PostgreSQLParserASSERT, PostgreSQLParserOPEN, PostgreSQLParserABS, PostgreSQLParserCBRT, PostgreSQLParserCEIL, PostgreSQLParserCEILING, PostgreSQLParserDEGREES, PostgreSQLParserDIV, PostgreSQLParserEXP, PostgreSQLParserFACTORIAL, PostgreSQLParserFLOOR, PostgreSQLParserGCD, PostgreSQLParserLCM, PostgreSQLParserLN, PostgreSQLParserLOG10, PostgreSQLParserMIN_SCALE, PostgreSQLParserMOD, PostgreSQLParserPI, PostgreSQLParserPOWER, PostgreSQLParserRADIANS, PostgreSQLParserROUND, PostgreSQLParserSCALE, PostgreSQLParserSIGN, PostgreSQLParserSQRT, PostgreSQLParserTRIM_SCALE, PostgreSQLParserTRUNC, PostgreSQLParserWIDTH_BUCKET, PostgreSQLParserRANDOM, PostgreSQLParserSETSEED, PostgreSQLParserACOS, PostgreSQLParserACOSD, PostgreSQLParserASIN, PostgreSQLParserASIND, PostgreSQLParserATAN, PostgreSQLParserATAND, PostgreSQLParserATAN2, PostgreSQLParserATAN2D, PostgreSQLParserCOS, PostgreSQLParserCOSD, PostgreSQLParserCOT, PostgreSQLParserCOTD, PostgreSQLParserSIN, PostgreSQLParserSIND, PostgreSQLParserTAN, PostgreSQLParserTAND, PostgreSQLParserSINH, PostgreSQLParserCOSH, PostgreSQLParserTANH, PostgreSQLParserASINH, PostgreSQLParserACOSH, PostgreSQLParserATANH, PostgreSQLParserBIT_LENGTH, PostgreSQLParserCHAR_LENGTH, PostgreSQLParserCHARACTER_LENGTH, PostgreSQLParserLOWER, PostgreSQLParserOCTET_LENGTH, PostgreSQLParserUPPER, PostgreSQLParserASCII, PostgreSQLParserBTRIM, PostgreSQLParserCHR, PostgreSQLParserCONCAT, PostgreSQLParserCONCAT_WS, PostgreSQLParserFORMAT, PostgreSQLParserINITCAP, PostgreSQLParserLENGTH, PostgreSQLParserLPAD, PostgreSQLParserLTRIM, PostgreSQLParserMD5, PostgreSQLParserPARSE_IDENT, PostgreSQLParserPG_CLIENT_ENCODING, PostgreSQLParserQUOTE_IDENT, PostgreSQLParserQUOTE_LITERAL, PostgreSQLParserQUOTE_NULLABLE, PostgreSQLParserREGEXP_COUNT, PostgreSQLParserREGEXP_INSTR, PostgreSQLParserREGEXP_LIKE, PostgreSQLParserREGEXP_MATCH, PostgreSQLParserREGEXP_MATCHES, PostgreSQLParserREGEXP_REPLACE, PostgreSQLParserREGEXP_SPLIT_TO_ARRAY, PostgreSQLParserREGEXP_SPLIT_TO_TABLE, PostgreSQLParserREGEXP_SUBSTR, PostgreSQLParserREPEAT, PostgreSQLParserRPAD, PostgreSQLParserRTRIM, PostgreSQLParserSPLIT_PART, PostgreSQLParserSTARTS_WITH, PostgreSQLParserSTRING_TO_ARRAY, PostgreSQLParserSTRING_TO_TABLE, PostgreSQLParserSTRPOS, PostgreSQLParserSUBSTR, PostgreSQLParserTO_ASCII, PostgreSQLParserTO_HEX, PostgreSQLParserTRANSLATE, PostgreSQLParserUNISTR, PostgreSQLParserAGE, PostgreSQLParserCLOCK_TIMESTAMP, PostgreSQLParserDATE_BIN, PostgreSQLParserDATE_PART, PostgreSQLParserDATE_TRUNC, PostgreSQLParserISFINITE, PostgreSQLParserJUSTIFY_DAYS, PostgreSQLParserJUSTIFY_HOURS, PostgreSQLParserJUSTIFY_INTERVAL, PostgreSQLParserMAKE_DATE, PostgreSQLParserMAKE_INTERVAL, PostgreSQLParserMAKE_TIME, PostgreSQLParserMAKE_TIMESTAMP, PostgreSQLParserMAKE_TIMESTAMPTZ, PostgreSQLParserNOW, PostgreSQLParserSTATEMENT_TIMESTAMP, PostgreSQLParserTIMEOFDAY, PostgreSQLParserTRANSACTION_TIMESTAMP, PostgreSQLParserTO_TIMESTAMP, PostgreSQLParserTO_CHAR, PostgreSQLParserTO_DATE, PostgreSQLParserTO_NUMBER, PostgreSQLParserIdentifier, PostgreSQLParserQuotedIdentifier, PostgreSQLParserUnicodeQuotedIdentifier, PostgreSQLParserPLSQLVARIABLENAME, PostgreSQLParserPLSQLIDENTIFIER:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(2031)
			p.Var_name()
		}

	case PostgreSQLParserALL:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(2032)
			p.Match(PostgreSQLParserALL)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	default:
		p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// ISetresetclauseContext is an interface to support dynamic dispatch.
type ISetresetclauseContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	SET() antlr.TerminalNode
	Set_rest() ISet_restContext
	Variableresetstmt() IVariableresetstmtContext

	// IsSetresetclauseContext differentiates from other interfaces.
	IsSetresetclauseContext()
}

type SetresetclauseContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptySetresetclauseContext() *SetresetclauseContext {
	var p = new(SetresetclauseContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_setresetclause
	return p
}

func InitEmptySetresetclauseContext(p *SetresetclauseContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_setresetclause
}

func (*SetresetclauseContext) IsSetresetclauseContext() {}

func NewSetresetclauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SetresetclauseContext {
	var p = new(SetresetclauseContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_setresetclause

	return p
}

func (s *SetresetclauseContext) GetParser() antlr.Parser { return s.parser }

func (s *SetresetclauseContext) SET() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserSET, 0)
}

func (s *SetresetclauseContext) Set_rest() ISet_restContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ISet_restContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ISet_restContext)
}

func (s *SetresetclauseContext) Variableresetstmt() IVariableresetstmtContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IVariableresetstmtContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IVariableresetstmtContext)
}

func (s *SetresetclauseContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *SetresetclauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *SetresetclauseContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterSetresetclause(s)
	}
}

func (s *SetresetclauseContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitSetresetclause(s)
	}
}

func (s *SetresetclauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitSetresetclause(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Setresetclause() (localctx ISetresetclauseContext) {
	localctx = NewSetresetclauseContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 80, PostgreSQLParserRULE_setresetclause)
	p.SetState(2038)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetTokenStream().LA(1) {
	case PostgreSQLParserSET:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(2035)
			p.Match(PostgreSQLParserSET)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2036)
			p.Set_rest()
		}

	case PostgreSQLParserRESET:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(2037)
			p.Variableresetstmt()
		}

	default:
		p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IFunctionsetresetclauseContext is an interface to support dynamic dispatch.
type IFunctionsetresetclauseContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	SET() antlr.TerminalNode
	Set_rest_more() ISet_rest_moreContext
	Variableresetstmt() IVariableresetstmtContext

	// IsFunctionsetresetclauseContext differentiates from other interfaces.
	IsFunctionsetresetclauseContext()
}

type FunctionsetresetclauseContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyFunctionsetresetclauseContext() *FunctionsetresetclauseContext {
	var p = new(FunctionsetresetclauseContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_functionsetresetclause
	return p
}

func InitEmptyFunctionsetresetclauseContext(p *FunctionsetresetclauseContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_functionsetresetclause
}

func (*FunctionsetresetclauseContext) IsFunctionsetresetclauseContext() {}

func NewFunctionsetresetclauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *FunctionsetresetclauseContext {
	var p = new(FunctionsetresetclauseContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_functionsetresetclause

	return p
}

func (s *FunctionsetresetclauseContext) GetParser() antlr.Parser { return s.parser }

func (s *FunctionsetresetclauseContext) SET() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserSET, 0)
}

func (s *FunctionsetresetclauseContext) Set_rest_more() ISet_rest_moreContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ISet_rest_moreContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ISet_rest_moreContext)
}

func (s *FunctionsetresetclauseContext) Variableresetstmt() IVariableresetstmtContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IVariableresetstmtContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IVariableresetstmtContext)
}

func (s *FunctionsetresetclauseContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *FunctionsetresetclauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *FunctionsetresetclauseContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterFunctionsetresetclause(s)
	}
}

func (s *FunctionsetresetclauseContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitFunctionsetresetclause(s)
	}
}

func (s *FunctionsetresetclauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitFunctionsetresetclause(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Functionsetresetclause() (localctx IFunctionsetresetclauseContext) {
	localctx = NewFunctionsetresetclauseContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 82, PostgreSQLParserRULE_functionsetresetclause)
	p.SetState(2043)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetTokenStream().LA(1) {
	case PostgreSQLParserSET:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(2040)
			p.Match(PostgreSQLParserSET)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2041)
			p.Set_rest_more()
		}

	case PostgreSQLParserRESET:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(2042)
			p.Variableresetstmt()
		}

	default:
		p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IVariableshowstmtContext is an interface to support dynamic dispatch.
type IVariableshowstmtContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	SHOW() antlr.TerminalNode
	Var_name() IVar_nameContext
	TIME() antlr.TerminalNode
	ZONE() antlr.TerminalNode
	TRANSACTION() antlr.TerminalNode
	ISOLATION() antlr.TerminalNode
	LEVEL() antlr.TerminalNode
	SESSION() antlr.TerminalNode
	AUTHORIZATION() antlr.TerminalNode
	ALL() antlr.TerminalNode

	// IsVariableshowstmtContext differentiates from other interfaces.
	IsVariableshowstmtContext()
}

type VariableshowstmtContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyVariableshowstmtContext() *VariableshowstmtContext {
	var p = new(VariableshowstmtContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_variableshowstmt
	return p
}

func InitEmptyVariableshowstmtContext(p *VariableshowstmtContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_variableshowstmt
}

func (*VariableshowstmtContext) IsVariableshowstmtContext() {}

func NewVariableshowstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *VariableshowstmtContext {
	var p = new(VariableshowstmtContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_variableshowstmt

	return p
}

func (s *VariableshowstmtContext) GetParser() antlr.Parser { return s.parser }

func (s *VariableshowstmtContext) SHOW() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserSHOW, 0)
}

func (s *VariableshowstmtContext) Var_name() IVar_nameContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IVar_nameContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IVar_nameContext)
}

func (s *VariableshowstmtContext) TIME() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserTIME, 0)
}

func (s *VariableshowstmtContext) ZONE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserZONE, 0)
}

func (s *VariableshowstmtContext) TRANSACTION() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserTRANSACTION, 0)
}

func (s *VariableshowstmtContext) ISOLATION() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserISOLATION, 0)
}

func (s *VariableshowstmtContext) LEVEL() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserLEVEL, 0)
}

func (s *VariableshowstmtContext) SESSION() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserSESSION, 0)
}

func (s *VariableshowstmtContext) AUTHORIZATION() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserAUTHORIZATION, 0)
}

func (s *VariableshowstmtContext) ALL() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserALL, 0)
}

func (s *VariableshowstmtContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *VariableshowstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *VariableshowstmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterVariableshowstmt(s)
	}
}

func (s *VariableshowstmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitVariableshowstmt(s)
	}
}

func (s *VariableshowstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitVariableshowstmt(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Variableshowstmt() (localctx IVariableshowstmtContext) {
	localctx = NewVariableshowstmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 84, PostgreSQLParserRULE_variableshowstmt)
	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(2045)
		p.Match(PostgreSQLParserSHOW)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	p.SetState(2055)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 33, p.GetParserRuleContext()) {
	case 1:
		{
			p.SetState(2046)
			p.Var_name()
		}

	case 2:
		{
			p.SetState(2047)
			p.Match(PostgreSQLParserTIME)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2048)
			p.Match(PostgreSQLParserZONE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 3:
		{
			p.SetState(2049)
			p.Match(PostgreSQLParserTRANSACTION)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2050)
			p.Match(PostgreSQLParserISOLATION)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2051)
			p.Match(PostgreSQLParserLEVEL)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 4:
		{
			p.SetState(2052)
			p.Match(PostgreSQLParserSESSION)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2053)
			p.Match(PostgreSQLParserAUTHORIZATION)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 5:
		{
			p.SetState(2054)
			p.Match(PostgreSQLParserALL)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case antlr.ATNInvalidAltNumber:
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IConstraintssetstmtContext is an interface to support dynamic dispatch.
type IConstraintssetstmtContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	SET() antlr.TerminalNode
	CONSTRAINTS() antlr.TerminalNode
	Constraints_set_list() IConstraints_set_listContext
	Constraints_set_mode() IConstraints_set_modeContext

	// IsConstraintssetstmtContext differentiates from other interfaces.
	IsConstraintssetstmtContext()
}

type ConstraintssetstmtContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyConstraintssetstmtContext() *ConstraintssetstmtContext {
	var p = new(ConstraintssetstmtContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_constraintssetstmt
	return p
}

func InitEmptyConstraintssetstmtContext(p *ConstraintssetstmtContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_constraintssetstmt
}

func (*ConstraintssetstmtContext) IsConstraintssetstmtContext() {}

func NewConstraintssetstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ConstraintssetstmtContext {
	var p = new(ConstraintssetstmtContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_constraintssetstmt

	return p
}

func (s *ConstraintssetstmtContext) GetParser() antlr.Parser { return s.parser }

func (s *ConstraintssetstmtContext) SET() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserSET, 0)
}

func (s *ConstraintssetstmtContext) CONSTRAINTS() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCONSTRAINTS, 0)
}

func (s *ConstraintssetstmtContext) Constraints_set_list() IConstraints_set_listContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IConstraints_set_listContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IConstraints_set_listContext)
}

func (s *ConstraintssetstmtContext) Constraints_set_mode() IConstraints_set_modeContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IConstraints_set_modeContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IConstraints_set_modeContext)
}

func (s *ConstraintssetstmtContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *ConstraintssetstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *ConstraintssetstmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterConstraintssetstmt(s)
	}
}

func (s *ConstraintssetstmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitConstraintssetstmt(s)
	}
}

func (s *ConstraintssetstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitConstraintssetstmt(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Constraintssetstmt() (localctx IConstraintssetstmtContext) {
	localctx = NewConstraintssetstmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 86, PostgreSQLParserRULE_constraintssetstmt)
	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(2057)
		p.Match(PostgreSQLParserSET)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(2058)
		p.Match(PostgreSQLParserCONSTRAINTS)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(2059)
		p.Constraints_set_list()
	}
	{
		p.SetState(2060)
		p.Constraints_set_mode()
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IConstraints_set_listContext is an interface to support dynamic dispatch.
type IConstraints_set_listContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	ALL() antlr.TerminalNode
	Qualified_name_list() IQualified_name_listContext

	// IsConstraints_set_listContext differentiates from other interfaces.
	IsConstraints_set_listContext()
}

type Constraints_set_listContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyConstraints_set_listContext() *Constraints_set_listContext {
	var p = new(Constraints_set_listContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_constraints_set_list
	return p
}

func InitEmptyConstraints_set_listContext(p *Constraints_set_listContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_constraints_set_list
}

func (*Constraints_set_listContext) IsConstraints_set_listContext() {}

func NewConstraints_set_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Constraints_set_listContext {
	var p = new(Constraints_set_listContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_constraints_set_list

	return p
}

func (s *Constraints_set_listContext) GetParser() antlr.Parser { return s.parser }

func (s *Constraints_set_listContext) ALL() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserALL, 0)
}

func (s *Constraints_set_listContext) Qualified_name_list() IQualified_name_listContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IQualified_name_listContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IQualified_name_listContext)
}

func (s *Constraints_set_listContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Constraints_set_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Constraints_set_listContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterConstraints_set_list(s)
	}
}

func (s *Constraints_set_listContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitConstraints_set_list(s)
	}
}

func (s *Constraints_set_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitConstraints_set_list(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Constraints_set_list() (localctx IConstraints_set_listContext) {
	localctx = NewConstraints_set_listContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 88, PostgreSQLParserRULE_constraints_set_list)
	p.SetState(2064)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetTokenStream().LA(1) {
	case PostgreSQLParserALL:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(2062)
			p.Match(PostgreSQLParserALL)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case PostgreSQLParserAND, PostgreSQLParserARRAY, PostgreSQLParserCOLLATE, PostgreSQLParserCOLUMN, PostgreSQLParserCONSTRAINT, PostgreSQLParserDEFAULT, PostgreSQLParserDO, PostgreSQLParserFETCH, PostgreSQLParserTABLE, PostgreSQLParserIS, PostgreSQLParserLEFT, PostgreSQLParserOUTER_P, PostgreSQLParserOVER, PostgreSQLParserRIGHT, PostgreSQLParserABORT_P, PostgreSQLParserABSOLUTE_P, PostgreSQLParserACCESS, PostgreSQLParserACTION, PostgreSQLParserADD_P, PostgreSQLParserADMIN, PostgreSQLParserAFTER, PostgreSQLParserAGGREGATE, PostgreSQLParserALSO, PostgreSQLParserALTER, PostgreSQLParserALWAYS, PostgreSQLParserASSERTION, PostgreSQLParserASSIGNMENT, PostgreSQLParserAT, PostgreSQLParserATTRIBUTE, PostgreSQLParserBACKWARD, PostgreSQLParserBEFORE, PostgreSQLParserBEGIN_P, PostgreSQLParserBY, PostgreSQLParserCACHE, PostgreSQLParserCALLED, PostgreSQLParserCASCADE, PostgreSQLParserCASCADED, PostgreSQLParserCATALOG, PostgreSQLParserCHAIN, PostgreSQLParserCHARACTERISTICS, PostgreSQLParserCHECKPOINT, PostgreSQLParserCLASS, PostgreSQLParserCLOSE, PostgreSQLParserCLUSTER, PostgreSQLParserCOMMENT, PostgreSQLParserCOMMENTS, PostgreSQLParserCOMMIT, PostgreSQLParserCOMMITTED, PostgreSQLParserCONFIGURATION, PostgreSQLParserCONNECTION, PostgreSQLParserCONSTRAINTS, PostgreSQLParserCONTENT_P, PostgreSQLParserCONTINUE_P, PostgreSQLParserCONVERSION_P, PostgreSQLParserCOPY, PostgreSQLParserCOST, PostgreSQLParserCSV, PostgreSQLParserCURSOR, PostgreSQLParserCYCLE, PostgreSQLParserDATA_P, PostgreSQLParserDATABASE, PostgreSQLParserDAY_P, PostgreSQLParserDEALLOCATE, PostgreSQLParserDECLARE, PostgreSQLParserDEFAULTS, PostgreSQLParserDEFERRED, PostgreSQLParserDEFINER, PostgreSQLParserDELETE_P, PostgreSQLParserDELIMITER, PostgreSQLParserDELIMITERS, PostgreSQLParserDICTIONARY, PostgreSQLParserDISABLE_P, PostgreSQLParserDISCARD, PostgreSQLParserDOCUMENT_P, PostgreSQLParserDOMAIN_P, PostgreSQLParserDOUBLE_P, PostgreSQLParserDROP, PostgreSQLParserEACH, PostgreSQLParserENABLE_P, PostgreSQLParserENCODING, PostgreSQLParserENCRYPTED, PostgreSQLParserENUM_P, PostgreSQLParserESCAPE, PostgreSQLParserEVENT, PostgreSQLParserEXCLUDE, PostgreSQLParserEXCLUDING, PostgreSQLParserEXCLUSIVE, PostgreSQLParserEXECUTE, PostgreSQLParserEXPLAIN, PostgreSQLParserEXTENSION, PostgreSQLParserEXTERNAL, PostgreSQLParserFAMILY, PostgreSQLParserFIRST_P, PostgreSQLParserFOLLOWING, PostgreSQLParserFORCE, PostgreSQLParserFORWARD, PostgreSQLParserFUNCTION, PostgreSQLParserFUNCTIONS, PostgreSQLParserGLOBAL, PostgreSQLParserGRANTED, PostgreSQLParserHANDLER, PostgreSQLParserHEADER_P, PostgreSQLParserHOLD, PostgreSQLParserHOUR_P, PostgreSQLParserIDENTITY_P, PostgreSQLParserIF_P, PostgreSQLParserIMMEDIATE, PostgreSQLParserIMMUTABLE, PostgreSQLParserIMPLICIT_P, PostgreSQLParserINCLUDING, PostgreSQLParserINCREMENT, PostgreSQLParserINDEX, PostgreSQLParserINDEXES, PostgreSQLParserINHERIT, PostgreSQLParserINHERITS, PostgreSQLParserINLINE_P, PostgreSQLParserINSENSITIVE, PostgreSQLParserINSERT, PostgreSQLParserINSTEAD, PostgreSQLParserINVOKER, PostgreSQLParserISOLATION, PostgreSQLParserKEY, PostgreSQLParserLABEL, PostgreSQLParserLANGUAGE, PostgreSQLParserLARGE_P, PostgreSQLParserLAST_P, PostgreSQLParserLEAKPROOF, PostgreSQLParserLEVEL, PostgreSQLParserLISTEN, PostgreSQLParserLOAD, PostgreSQLParserLOCAL, PostgreSQLParserLOCATION, PostgreSQLParserLOCK_P, PostgreSQLParserMAPPING, PostgreSQLParserMATCH, PostgreSQLParserMATERIALIZED, PostgreSQLParserMAXVALUE, PostgreSQLParserMINUTE_P, PostgreSQLParserMINVALUE, PostgreSQLParserMODE, PostgreSQLParserMONTH_P, PostgreSQLParserMOVE, PostgreSQLParserNAME_P, PostgreSQLParserNAMES, PostgreSQLParserNEXT, PostgreSQLParserNO, PostgreSQLParserNOTHING, PostgreSQLParserNOTIFY, PostgreSQLParserNOWAIT, PostgreSQLParserNULLS_P, PostgreSQLParserOBJECT_P, PostgreSQLParserOF, PostgreSQLParserOFF, PostgreSQLParserOIDS, PostgreSQLParserOPERATOR, PostgreSQLParserOPTION, PostgreSQLParserOPTIONS, PostgreSQLParserOWNED, PostgreSQLParserOWNER, PostgreSQLParserPARSER, PostgreSQLParserPARTIAL, PostgreSQLParserPARTITION, PostgreSQLParserPASSING, PostgreSQLParserPASSWORD, PostgreSQLParserPLANS, PostgreSQLParserPRECEDING, PostgreSQLParserPREPARE, PostgreSQLParserPREPARED, PostgreSQLParserPRESERVE, PostgreSQLParserPRIOR, PostgreSQLParserPRIVILEGES, PostgreSQLParserPROCEDURAL, PostgreSQLParserPROCEDURE, PostgreSQLParserPROGRAM, PostgreSQLParserQUOTE, PostgreSQLParserRANGE, PostgreSQLParserREAD, PostgreSQLParserREASSIGN, PostgreSQLParserRECHECK, PostgreSQLParserRECURSIVE, PostgreSQLParserREF, PostgreSQLParserREFRESH, PostgreSQLParserREINDEX, PostgreSQLParserRELATIVE_P, PostgreSQLParserRELEASE, PostgreSQLParserRENAME, PostgreSQLParserREPEATABLE, PostgreSQLParserREPLACE, PostgreSQLParserREPLICA, PostgreSQLParserRESET, PostgreSQLParserRESTART, PostgreSQLParserRESTRICT, PostgreSQLParserRETURNS, PostgreSQLParserREVOKE, PostgreSQLParserROLE, PostgreSQLParserROLLBACK, PostgreSQLParserROWS, PostgreSQLParserRULE, PostgreSQLParserSAVEPOINT, PostgreSQLParserSCHEMA, PostgreSQLParserSCROLL, PostgreSQLParserSEARCH, PostgreSQLParserSECOND_P, PostgreSQLParserSECURITY, PostgreSQLParserSEQUENCE, PostgreSQLParserSEQUENCES, PostgreSQLParserSERIALIZABLE, PostgreSQLParserSERVER, PostgreSQLParserSESSION, PostgreSQLParserSET, PostgreSQLParserSHARE, PostgreSQLParserSHOW, PostgreSQLParserSIMPLE, PostgreSQLParserSNAPSHOT, PostgreSQLParserSTABLE, PostgreSQLParserSTANDALONE_P, PostgreSQLParserSTART, PostgreSQLParserSTATEMENT, PostgreSQLParserSTATISTICS, PostgreSQLParserSTDIN, PostgreSQLParserSTDOUT, PostgreSQLParserSTORAGE, PostgreSQLParserSTRICT_P, PostgreSQLParserSTRIP_P, PostgreSQLParserSYSID, PostgreSQLParserSYSTEM_P, PostgreSQLParserTABLES, PostgreSQLParserTABLESPACE, PostgreSQLParserTEMP, PostgreSQLParserTEMPLATE, PostgreSQLParserTEMPORARY, PostgreSQLParserTEXT_P, PostgreSQLParserTRANSACTION, PostgreSQLParserTRIGGER, PostgreSQLParserTRUNCATE, PostgreSQLParserTRUSTED, PostgreSQLParserTYPE_P, PostgreSQLParserTYPES_P, PostgreSQLParserUNBOUNDED, PostgreSQLParserUNCOMMITTED, PostgreSQLParserUNENCRYPTED, PostgreSQLParserUNKNOWN, PostgreSQLParserUNLISTEN, PostgreSQLParserUNLOGGED, PostgreSQLParserUNTIL, PostgreSQLParserUPDATE, PostgreSQLParserVACUUM, PostgreSQLParserVALID, PostgreSQLParserVALIDATE, PostgreSQLParserVALIDATOR, PostgreSQLParserVARYING, PostgreSQLParserVERSION_P, PostgreSQLParserVIEW, PostgreSQLParserVOLATILE, PostgreSQLParserWHITESPACE_P, PostgreSQLParserWITHOUT, PostgreSQLParserWORK, PostgreSQLParserWRAPPER, PostgreSQLParserWRITE, PostgreSQLParserXML_P, PostgreSQLParserYEAR_P, PostgreSQLParserYES_P, PostgreSQLParserZONE, PostgreSQLParserBETWEEN, PostgreSQLParserBIGINT, PostgreSQLParserBIT, PostgreSQLParserBOOLEAN_P, PostgreSQLParserCHAR_P, PostgreSQLParserCHARACTER, PostgreSQLParserCOALESCE, PostgreSQLParserDEC, PostgreSQLParserDECIMAL_P, PostgreSQLParserEXISTS, PostgreSQLParserEXTRACT, PostgreSQLParserFLOAT_P, PostgreSQLParserGREATEST, PostgreSQLParserINOUT, PostgreSQLParserINT_P, PostgreSQLParserINTEGER, PostgreSQLParserINTERVAL, PostgreSQLParserLEAST, PostgreSQLParserNATIONAL, PostgreSQLParserNCHAR, PostgreSQLParserNONE, PostgreSQLParserNULLIF, PostgreSQLParserNUMERIC, PostgreSQLParserOVERLAY, PostgreSQLParserPOSITION, PostgreSQLParserPRECISION, PostgreSQLParserREAL, PostgreSQLParserROW, PostgreSQLParserSETOF, PostgreSQLParserSMALLINT, PostgreSQLParserSUBSTRING, PostgreSQLParserTIME, PostgreSQLParserTIMESTAMP, PostgreSQLParserTREAT, PostgreSQLParserTRIM, PostgreSQLParserVALUES, PostgreSQLParserVARCHAR, PostgreSQLParserXMLATTRIBUTES, PostgreSQLParserXMLCOMMENT, PostgreSQLParserXMLAGG, PostgreSQLParserXML_IS_WELL_FORMED, PostgreSQLParserXML_IS_WELL_FORMED_DOCUMENT, PostgreSQLParserXML_IS_WELL_FORMED_CONTENT, PostgreSQLParserXPATH, PostgreSQLParserXPATH_EXISTS, PostgreSQLParserXMLCONCAT, PostgreSQLParserXMLELEMENT, PostgreSQLParserXMLEXISTS, PostgreSQLParserXMLFOREST, PostgreSQLParserXMLPARSE, PostgreSQLParserXMLPI, PostgreSQLParserXMLROOT, PostgreSQLParserXMLSERIALIZE, PostgreSQLParserCALL, PostgreSQLParserCURRENT_P, PostgreSQLParserATTACH, PostgreSQLParserDETACH, PostgreSQLParserEXPRESSION, PostgreSQLParserGENERATED, PostgreSQLParserLOGGED, PostgreSQLParserSTORED, PostgreSQLParserINCLUDE, PostgreSQLParserROUTINE, PostgreSQLParserTRANSFORM, PostgreSQLParserIMPORT_P, PostgreSQLParserPOLICY, PostgreSQLParserMETHOD, PostgreSQLParserREFERENCING, PostgreSQLParserNEW, PostgreSQLParserOLD, PostgreSQLParserVALUE_P, PostgreSQLParserSUBSCRIPTION, PostgreSQLParserPUBLICATION, PostgreSQLParserOUT_P, PostgreSQLParserROUTINES, PostgreSQLParserSCHEMAS, PostgreSQLParserPROCEDURES, PostgreSQLParserINPUT_P, PostgreSQLParserSUPPORT, PostgreSQLParserPARALLEL, PostgreSQLParserSQL_P, PostgreSQLParserDEPENDS, PostgreSQLParserOVERRIDING, PostgreSQLParserCONFLICT, PostgreSQLParserSKIP_P, PostgreSQLParserLOCKED, PostgreSQLParserTIES, PostgreSQLParserROLLUP, PostgreSQLParserCUBE, PostgreSQLParserGROUPING, PostgreSQLParserSETS, PostgreSQLParserORDINALITY, PostgreSQLParserXMLTABLE, PostgreSQLParserCOLUMNS, PostgreSQLParserXMLNAMESPACES, PostgreSQLParserROWTYPE, PostgreSQLParserNORMALIZED, PostgreSQLParserWITHIN, PostgreSQLParserFILTER, PostgreSQLParserGROUPS, PostgreSQLParserOTHERS, PostgreSQLParserNFC, PostgreSQLParserNFD, PostgreSQLParserNFKC, PostgreSQLParserNFKD, PostgreSQLParserUESCAPE, PostgreSQLParserVIEWS, PostgreSQLParserNORMALIZE, PostgreSQLParserDUMP, PostgreSQLParserPRINT_STRICT_PARAMS, PostgreSQLParserVARIABLE_CONFLICT, PostgreSQLParserERROR, PostgreSQLParserUSE_VARIABLE, PostgreSQLParserUSE_COLUMN, PostgreSQLParserALIAS, PostgreSQLParserCONSTANT, PostgreSQLParserPERFORM, PostgreSQLParserGET, PostgreSQLParserDIAGNOSTICS, PostgreSQLParserSTACKED, PostgreSQLParserELSIF, PostgreSQLParserREVERSE, PostgreSQLParserSLICE, PostgreSQLParserEXIT, PostgreSQLParserRETURN, PostgreSQLParserQUERY, PostgreSQLParserRAISE, PostgreSQLParserSQLSTATE, PostgreSQLParserDEBUG, PostgreSQLParserLOG, PostgreSQLParserINFO, PostgreSQLParserNOTICE, PostgreSQLParserWARNING, PostgreSQLParserEXCEPTION, PostgreSQLParserASSERT, PostgreSQLParserOPEN, PostgreSQLParserABS, PostgreSQLParserCBRT, PostgreSQLParserCEIL, PostgreSQLParserCEILING, PostgreSQLParserDEGREES, PostgreSQLParserDIV, PostgreSQLParserEXP, PostgreSQLParserFACTORIAL, PostgreSQLParserFLOOR, PostgreSQLParserGCD, PostgreSQLParserLCM, PostgreSQLParserLN, PostgreSQLParserLOG10, PostgreSQLParserMIN_SCALE, PostgreSQLParserMOD, PostgreSQLParserPI, PostgreSQLParserPOWER, PostgreSQLParserRADIANS, PostgreSQLParserROUND, PostgreSQLParserSCALE, PostgreSQLParserSIGN, PostgreSQLParserSQRT, PostgreSQLParserTRIM_SCALE, PostgreSQLParserTRUNC, PostgreSQLParserWIDTH_BUCKET, PostgreSQLParserRANDOM, PostgreSQLParserSETSEED, PostgreSQLParserACOS, PostgreSQLParserACOSD, PostgreSQLParserASIN, PostgreSQLParserASIND, PostgreSQLParserATAN, PostgreSQLParserATAND, PostgreSQLParserATAN2, PostgreSQLParserATAN2D, PostgreSQLParserCOS, PostgreSQLParserCOSD, PostgreSQLParserCOT, PostgreSQLParserCOTD, PostgreSQLParserSIN, PostgreSQLParserSIND, PostgreSQLParserTAN, PostgreSQLParserTAND, PostgreSQLParserSINH, PostgreSQLParserCOSH, PostgreSQLParserTANH, PostgreSQLParserASINH, PostgreSQLParserACOSH, PostgreSQLParserATANH, PostgreSQLParserBIT_LENGTH, PostgreSQLParserCHAR_LENGTH, PostgreSQLParserCHARACTER_LENGTH, PostgreSQLParserLOWER, PostgreSQLParserOCTET_LENGTH, PostgreSQLParserUPPER, PostgreSQLParserASCII, PostgreSQLParserBTRIM, PostgreSQLParserCHR, PostgreSQLParserCONCAT, PostgreSQLParserCONCAT_WS, PostgreSQLParserFORMAT, PostgreSQLParserINITCAP, PostgreSQLParserLENGTH, PostgreSQLParserLPAD, PostgreSQLParserLTRIM, PostgreSQLParserMD5, PostgreSQLParserPARSE_IDENT, PostgreSQLParserPG_CLIENT_ENCODING, PostgreSQLParserQUOTE_IDENT, PostgreSQLParserQUOTE_LITERAL, PostgreSQLParserQUOTE_NULLABLE, PostgreSQLParserREGEXP_COUNT, PostgreSQLParserREGEXP_INSTR, PostgreSQLParserREGEXP_LIKE, PostgreSQLParserREGEXP_MATCH, PostgreSQLParserREGEXP_MATCHES, PostgreSQLParserREGEXP_REPLACE, PostgreSQLParserREGEXP_SPLIT_TO_ARRAY, PostgreSQLParserREGEXP_SPLIT_TO_TABLE, PostgreSQLParserREGEXP_SUBSTR, PostgreSQLParserREPEAT, PostgreSQLParserRPAD, PostgreSQLParserRTRIM, PostgreSQLParserSPLIT_PART, PostgreSQLParserSTARTS_WITH, PostgreSQLParserSTRING_TO_ARRAY, PostgreSQLParserSTRING_TO_TABLE, PostgreSQLParserSTRPOS, PostgreSQLParserSUBSTR, PostgreSQLParserTO_ASCII, PostgreSQLParserTO_HEX, PostgreSQLParserTRANSLATE, PostgreSQLParserUNISTR, PostgreSQLParserAGE, PostgreSQLParserCLOCK_TIMESTAMP, PostgreSQLParserDATE_BIN, PostgreSQLParserDATE_PART, PostgreSQLParserDATE_TRUNC, PostgreSQLParserISFINITE, PostgreSQLParserJUSTIFY_DAYS, PostgreSQLParserJUSTIFY_HOURS, PostgreSQLParserJUSTIFY_INTERVAL, PostgreSQLParserMAKE_DATE, PostgreSQLParserMAKE_INTERVAL, PostgreSQLParserMAKE_TIME, PostgreSQLParserMAKE_TIMESTAMP, PostgreSQLParserMAKE_TIMESTAMPTZ, PostgreSQLParserNOW, PostgreSQLParserSTATEMENT_TIMESTAMP, PostgreSQLParserTIMEOFDAY, PostgreSQLParserTRANSACTION_TIMESTAMP, PostgreSQLParserTO_TIMESTAMP, PostgreSQLParserTO_CHAR, PostgreSQLParserTO_DATE, PostgreSQLParserTO_NUMBER, PostgreSQLParserIdentifier, PostgreSQLParserQuotedIdentifier, PostgreSQLParserUnicodeQuotedIdentifier, PostgreSQLParserPLSQLVARIABLENAME, PostgreSQLParserPLSQLIDENTIFIER:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(2063)
			p.Qualified_name_list()
		}

	default:
		p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IConstraints_set_modeContext is an interface to support dynamic dispatch.
type IConstraints_set_modeContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	DEFERRED() antlr.TerminalNode
	IMMEDIATE() antlr.TerminalNode

	// IsConstraints_set_modeContext differentiates from other interfaces.
	IsConstraints_set_modeContext()
}

type Constraints_set_modeContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyConstraints_set_modeContext() *Constraints_set_modeContext {
	var p = new(Constraints_set_modeContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_constraints_set_mode
	return p
}

func InitEmptyConstraints_set_modeContext(p *Constraints_set_modeContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_constraints_set_mode
}

func (*Constraints_set_modeContext) IsConstraints_set_modeContext() {}

func NewConstraints_set_modeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Constraints_set_modeContext {
	var p = new(Constraints_set_modeContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_constraints_set_mode

	return p
}

func (s *Constraints_set_modeContext) GetParser() antlr.Parser { return s.parser }

func (s *Constraints_set_modeContext) DEFERRED() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserDEFERRED, 0)
}

func (s *Constraints_set_modeContext) IMMEDIATE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserIMMEDIATE, 0)
}

func (s *Constraints_set_modeContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Constraints_set_modeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Constraints_set_modeContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterConstraints_set_mode(s)
	}
}

func (s *Constraints_set_modeContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitConstraints_set_mode(s)
	}
}

func (s *Constraints_set_modeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitConstraints_set_mode(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Constraints_set_mode() (localctx IConstraints_set_modeContext) {
	localctx = NewConstraints_set_modeContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 90, PostgreSQLParserRULE_constraints_set_mode)
	var _la int

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(2066)
		_la = p.GetTokenStream().LA(1)

		if !(_la == PostgreSQLParserDEFERRED || _la == PostgreSQLParserIMMEDIATE) {
			p.GetErrorHandler().RecoverInline(p)
		} else {
			p.GetErrorHandler().ReportMatch(p)
			p.Consume()
		}
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// ICheckpointstmtContext is an interface to support dynamic dispatch.
type ICheckpointstmtContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	CHECKPOINT() antlr.TerminalNode

	// IsCheckpointstmtContext differentiates from other interfaces.
	IsCheckpointstmtContext()
}

type CheckpointstmtContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyCheckpointstmtContext() *CheckpointstmtContext {
	var p = new(CheckpointstmtContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_checkpointstmt
	return p
}

func InitEmptyCheckpointstmtContext(p *CheckpointstmtContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_checkpointstmt
}

func (*CheckpointstmtContext) IsCheckpointstmtContext() {}

func NewCheckpointstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CheckpointstmtContext {
	var p = new(CheckpointstmtContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_checkpointstmt

	return p
}

func (s *CheckpointstmtContext) GetParser() antlr.Parser { return s.parser }

func (s *CheckpointstmtContext) CHECKPOINT() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCHECKPOINT, 0)
}

func (s *CheckpointstmtContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *CheckpointstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *CheckpointstmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterCheckpointstmt(s)
	}
}

func (s *CheckpointstmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitCheckpointstmt(s)
	}
}

func (s *CheckpointstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitCheckpointstmt(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Checkpointstmt() (localctx ICheckpointstmtContext) {
	localctx = NewCheckpointstmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 92, PostgreSQLParserRULE_checkpointstmt)
	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(2068)
		p.Match(PostgreSQLParserCHECKPOINT)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IDiscardstmtContext is an interface to support dynamic dispatch.
type IDiscardstmtContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	DISCARD() antlr.TerminalNode
	ALL() antlr.TerminalNode
	TEMP() antlr.TerminalNode
	TEMPORARY() antlr.TerminalNode
	PLANS() antlr.TerminalNode
	SEQUENCES() antlr.TerminalNode

	// IsDiscardstmtContext differentiates from other interfaces.
	IsDiscardstmtContext()
}

type DiscardstmtContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyDiscardstmtContext() *DiscardstmtContext {
	var p = new(DiscardstmtContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_discardstmt
	return p
}

func InitEmptyDiscardstmtContext(p *DiscardstmtContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_discardstmt
}

func (*DiscardstmtContext) IsDiscardstmtContext() {}

func NewDiscardstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DiscardstmtContext {
	var p = new(DiscardstmtContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_discardstmt

	return p
}

func (s *DiscardstmtContext) GetParser() antlr.Parser { return s.parser }

func (s *DiscardstmtContext) DISCARD() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserDISCARD, 0)
}

func (s *DiscardstmtContext) ALL() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserALL, 0)
}

func (s *DiscardstmtContext) TEMP() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserTEMP, 0)
}

func (s *DiscardstmtContext) TEMPORARY() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserTEMPORARY, 0)
}

func (s *DiscardstmtContext) PLANS() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserPLANS, 0)
}

func (s *DiscardstmtContext) SEQUENCES() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserSEQUENCES, 0)
}

func (s *DiscardstmtContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *DiscardstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *DiscardstmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterDiscardstmt(s)
	}
}

func (s *DiscardstmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitDiscardstmt(s)
	}
}

func (s *DiscardstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitDiscardstmt(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Discardstmt() (localctx IDiscardstmtContext) {
	localctx = NewDiscardstmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 94, PostgreSQLParserRULE_discardstmt)
	var _la int

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(2070)
		p.Match(PostgreSQLParserDISCARD)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(2071)
		_la = p.GetTokenStream().LA(1)

		if !(_la == PostgreSQLParserALL || _la == PostgreSQLParserPLANS || _la == PostgreSQLParserSEQUENCES || _la == PostgreSQLParserTEMP || _la == PostgreSQLParserTEMPORARY) {
			p.GetErrorHandler().RecoverInline(p)
		} else {
			p.GetErrorHandler().ReportMatch(p)
			p.Consume()
		}
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IAltertablestmtContext is an interface to support dynamic dispatch.
type IAltertablestmtContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	ALTER() antlr.TerminalNode
	TABLE() antlr.TerminalNode
	Relation_expr() IRelation_exprContext
	Alter_table_cmds() IAlter_table_cmdsContext
	Partition_cmd() IPartition_cmdContext
	IF_P() antlr.TerminalNode
	EXISTS() antlr.TerminalNode
	ALL() antlr.TerminalNode
	IN_P() antlr.TerminalNode
	AllTABLESPACE() []antlr.TerminalNode
	TABLESPACE(i int) antlr.TerminalNode
	AllName() []INameContext
	Name(i int) INameContext
	SET() antlr.TerminalNode
	Opt_nowait() IOpt_nowaitContext
	OWNED() antlr.TerminalNode
	BY() antlr.TerminalNode
	Role_list() IRole_listContext
	INDEX() antlr.TerminalNode
	Qualified_name() IQualified_nameContext
	Index_partition_cmd() IIndex_partition_cmdContext
	SEQUENCE() antlr.TerminalNode
	VIEW() antlr.TerminalNode
	MATERIALIZED() antlr.TerminalNode
	FOREIGN() antlr.TerminalNode

	// IsAltertablestmtContext differentiates from other interfaces.
	IsAltertablestmtContext()
}

type AltertablestmtContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyAltertablestmtContext() *AltertablestmtContext {
	var p = new(AltertablestmtContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_altertablestmt
	return p
}

func InitEmptyAltertablestmtContext(p *AltertablestmtContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_altertablestmt
}

func (*AltertablestmtContext) IsAltertablestmtContext() {}

func NewAltertablestmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AltertablestmtContext {
	var p = new(AltertablestmtContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_altertablestmt

	return p
}

func (s *AltertablestmtContext) GetParser() antlr.Parser { return s.parser }

func (s *AltertablestmtContext) ALTER() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserALTER, 0)
}

func (s *AltertablestmtContext) TABLE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserTABLE, 0)
}

func (s *AltertablestmtContext) Relation_expr() IRelation_exprContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IRelation_exprContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IRelation_exprContext)
}

func (s *AltertablestmtContext) Alter_table_cmds() IAlter_table_cmdsContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IAlter_table_cmdsContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IAlter_table_cmdsContext)
}

func (s *AltertablestmtContext) Partition_cmd() IPartition_cmdContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IPartition_cmdContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IPartition_cmdContext)
}

func (s *AltertablestmtContext) IF_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserIF_P, 0)
}

func (s *AltertablestmtContext) EXISTS() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserEXISTS, 0)
}

func (s *AltertablestmtContext) ALL() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserALL, 0)
}

func (s *AltertablestmtContext) IN_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserIN_P, 0)
}

func (s *AltertablestmtContext) AllTABLESPACE() []antlr.TerminalNode {
	return s.GetTokens(PostgreSQLParserTABLESPACE)
}

func (s *AltertablestmtContext) TABLESPACE(i int) antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserTABLESPACE, i)
}

func (s *AltertablestmtContext) AllName() []INameContext {
	children := s.GetChildren()
	len := 0
	for _, ctx := range children {
		if _, ok := ctx.(INameContext); ok {
			len++
		}
	}

	tst := make([]INameContext, len)
	i := 0
	for _, ctx := range children {
		if t, ok := ctx.(INameContext); ok {
			tst[i] = t.(INameContext)
			i++
		}
	}

	return tst
}

func (s *AltertablestmtContext) Name(i int) INameContext {
	var t antlr.RuleContext
	j := 0
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(INameContext); ok {
			if j == i {
				t = ctx.(antlr.RuleContext)
				break
			}
			j++
		}
	}

	if t == nil {
		return nil
	}

	return t.(INameContext)
}

func (s *AltertablestmtContext) SET() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserSET, 0)
}

func (s *AltertablestmtContext) Opt_nowait() IOpt_nowaitContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOpt_nowaitContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOpt_nowaitContext)
}

func (s *AltertablestmtContext) OWNED() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserOWNED, 0)
}

func (s *AltertablestmtContext) BY() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserBY, 0)
}

func (s *AltertablestmtContext) Role_list() IRole_listContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IRole_listContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IRole_listContext)
}

func (s *AltertablestmtContext) INDEX() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserINDEX, 0)
}

func (s *AltertablestmtContext) Qualified_name() IQualified_nameContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IQualified_nameContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IQualified_nameContext)
}

func (s *AltertablestmtContext) Index_partition_cmd() IIndex_partition_cmdContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IIndex_partition_cmdContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IIndex_partition_cmdContext)
}

func (s *AltertablestmtContext) SEQUENCE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserSEQUENCE, 0)
}

func (s *AltertablestmtContext) VIEW() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserVIEW, 0)
}

func (s *AltertablestmtContext) MATERIALIZED() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserMATERIALIZED, 0)
}

func (s *AltertablestmtContext) FOREIGN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserFOREIGN, 0)
}

func (s *AltertablestmtContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *AltertablestmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *AltertablestmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterAltertablestmt(s)
	}
}

func (s *AltertablestmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitAltertablestmt(s)
	}
}

func (s *AltertablestmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitAltertablestmt(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Altertablestmt() (localctx IAltertablestmtContext) {
	localctx = NewAltertablestmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 96, PostgreSQLParserRULE_altertablestmt)
	var _la int

	p.SetState(2182)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 46, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(2073)
			p.Match(PostgreSQLParserALTER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2074)
			p.Match(PostgreSQLParserTABLE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		p.SetState(2077)
		p.GetErrorHandler().Sync(p)

		if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 35, p.GetParserRuleContext()) == 1 {
			{
				p.SetState(2075)
				p.Match(PostgreSQLParserIF_P)
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}
			{
				p.SetState(2076)
				p.Match(PostgreSQLParserEXISTS)
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}

		} else if p.HasError() { // JIM
			goto errorExit
		}
		{
			p.SetState(2079)
			p.Relation_expr()
		}
		p.SetState(2082)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}

		switch p.GetTokenStream().LA(1) {
		case PostgreSQLParserNOT, PostgreSQLParserADD_P, PostgreSQLParserALTER, PostgreSQLParserCLUSTER, PostgreSQLParserDISABLE_P, PostgreSQLParserDROP, PostgreSQLParserENABLE_P, PostgreSQLParserFORCE, PostgreSQLParserINHERIT, PostgreSQLParserNO, PostgreSQLParserOF, PostgreSQLParserOPTIONS, PostgreSQLParserOWNER, PostgreSQLParserREPLICA, PostgreSQLParserRESET, PostgreSQLParserSET, PostgreSQLParserVALIDATE:
			{
				p.SetState(2080)
				p.Alter_table_cmds()
			}

		case PostgreSQLParserATTACH, PostgreSQLParserDETACH:
			{
				p.SetState(2081)
				p.Partition_cmd()
			}

		default:
			p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
			goto errorExit
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(2084)
			p.Match(PostgreSQLParserALTER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2085)
			p.Match(PostgreSQLParserTABLE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2086)
			p.Match(PostgreSQLParserALL)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2087)
			p.Match(PostgreSQLParserIN_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2088)
			p.Match(PostgreSQLParserTABLESPACE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2089)
			p.Name()
		}
		p.SetState(2093)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}
		_la = p.GetTokenStream().LA(1)

		if _la == PostgreSQLParserOWNED {
			{
				p.SetState(2090)
				p.Match(PostgreSQLParserOWNED)
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}
			{
				p.SetState(2091)
				p.Match(PostgreSQLParserBY)
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}
			{
				p.SetState(2092)
				p.Role_list()
			}

		}
		{
			p.SetState(2095)
			p.Match(PostgreSQLParserSET)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2096)
			p.Match(PostgreSQLParserTABLESPACE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2097)
			p.Name()
		}
		{
			p.SetState(2098)
			p.Opt_nowait()
		}

	case 3:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(2100)
			p.Match(PostgreSQLParserALTER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2101)
			p.Match(PostgreSQLParserINDEX)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		p.SetState(2104)
		p.GetErrorHandler().Sync(p)

		if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 38, p.GetParserRuleContext()) == 1 {
			{
				p.SetState(2102)
				p.Match(PostgreSQLParserIF_P)
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}
			{
				p.SetState(2103)
				p.Match(PostgreSQLParserEXISTS)
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}

		} else if p.HasError() { // JIM
			goto errorExit
		}
		{
			p.SetState(2106)
			p.Qualified_name()
		}
		p.SetState(2109)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}

		switch p.GetTokenStream().LA(1) {
		case PostgreSQLParserNOT, PostgreSQLParserADD_P, PostgreSQLParserALTER, PostgreSQLParserCLUSTER, PostgreSQLParserDISABLE_P, PostgreSQLParserDROP, PostgreSQLParserENABLE_P, PostgreSQLParserFORCE, PostgreSQLParserINHERIT, PostgreSQLParserNO, PostgreSQLParserOF, PostgreSQLParserOPTIONS, PostgreSQLParserOWNER, PostgreSQLParserREPLICA, PostgreSQLParserRESET, PostgreSQLParserSET, PostgreSQLParserVALIDATE:
			{
				p.SetState(2107)
				p.Alter_table_cmds()
			}

		case PostgreSQLParserATTACH:
			{
				p.SetState(2108)
				p.Index_partition_cmd()
			}

		default:
			p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
			goto errorExit
		}

	case 4:
		p.EnterOuterAlt(localctx, 4)
		{
			p.SetState(2111)
			p.Match(PostgreSQLParserALTER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2112)
			p.Match(PostgreSQLParserINDEX)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2113)
			p.Match(PostgreSQLParserALL)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2114)
			p.Match(PostgreSQLParserIN_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2115)
			p.Match(PostgreSQLParserTABLESPACE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2116)
			p.Name()
		}
		p.SetState(2120)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}
		_la = p.GetTokenStream().LA(1)

		if _la == PostgreSQLParserOWNED {
			{
				p.SetState(2117)
				p.Match(PostgreSQLParserOWNED)
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}
			{
				p.SetState(2118)
				p.Match(PostgreSQLParserBY)
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}
			{
				p.SetState(2119)
				p.Role_list()
			}

		}
		{
			p.SetState(2122)
			p.Match(PostgreSQLParserSET)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2123)
			p.Match(PostgreSQLParserTABLESPACE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2124)
			p.Name()
		}
		{
			p.SetState(2125)
			p.Opt_nowait()
		}

	case 5:
		p.EnterOuterAlt(localctx, 5)
		{
			p.SetState(2127)
			p.Match(PostgreSQLParserALTER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2128)
			p.Match(PostgreSQLParserSEQUENCE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		p.SetState(2131)
		p.GetErrorHandler().Sync(p)

		if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 41, p.GetParserRuleContext()) == 1 {
			{
				p.SetState(2129)
				p.Match(PostgreSQLParserIF_P)
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}
			{
				p.SetState(2130)
				p.Match(PostgreSQLParserEXISTS)
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}

		} else if p.HasError() { // JIM
			goto errorExit
		}
		{
			p.SetState(2133)
			p.Qualified_name()
		}
		{
			p.SetState(2134)
			p.Alter_table_cmds()
		}

	case 6:
		p.EnterOuterAlt(localctx, 6)
		{
			p.SetState(2136)
			p.Match(PostgreSQLParserALTER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2137)
			p.Match(PostgreSQLParserVIEW)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		p.SetState(2140)
		p.GetErrorHandler().Sync(p)

		if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 42, p.GetParserRuleContext()) == 1 {
			{
				p.SetState(2138)
				p.Match(PostgreSQLParserIF_P)
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}
			{
				p.SetState(2139)
				p.Match(PostgreSQLParserEXISTS)
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}

		} else if p.HasError() { // JIM
			goto errorExit
		}
		{
			p.SetState(2142)
			p.Qualified_name()
		}
		{
			p.SetState(2143)
			p.Alter_table_cmds()
		}

	case 7:
		p.EnterOuterAlt(localctx, 7)
		{
			p.SetState(2145)
			p.Match(PostgreSQLParserALTER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2146)
			p.Match(PostgreSQLParserMATERIALIZED)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2147)
			p.Match(PostgreSQLParserVIEW)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		p.SetState(2150)
		p.GetErrorHandler().Sync(p)

		if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 43, p.GetParserRuleContext()) == 1 {
			{
				p.SetState(2148)
				p.Match(PostgreSQLParserIF_P)
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}
			{
				p.SetState(2149)
				p.Match(PostgreSQLParserEXISTS)
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}

		} else if p.HasError() { // JIM
			goto errorExit
		}
		{
			p.SetState(2152)
			p.Qualified_name()
		}
		{
			p.SetState(2153)
			p.Alter_table_cmds()
		}

	case 8:
		p.EnterOuterAlt(localctx, 8)
		{
			p.SetState(2155)
			p.Match(PostgreSQLParserALTER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2156)
			p.Match(PostgreSQLParserMATERIALIZED)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2157)
			p.Match(PostgreSQLParserVIEW)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2158)
			p.Match(PostgreSQLParserALL)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2159)
			p.Match(PostgreSQLParserIN_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2160)
			p.Match(PostgreSQLParserTABLESPACE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2161)
			p.Name()
		}
		p.SetState(2165)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}
		_la = p.GetTokenStream().LA(1)

		if _la == PostgreSQLParserOWNED {
			{
				p.SetState(2162)
				p.Match(PostgreSQLParserOWNED)
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}
			{
				p.SetState(2163)
				p.Match(PostgreSQLParserBY)
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}
			{
				p.SetState(2164)
				p.Role_list()
			}

		}
		{
			p.SetState(2167)
			p.Match(PostgreSQLParserSET)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2168)
			p.Match(PostgreSQLParserTABLESPACE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2169)
			p.Name()
		}
		{
			p.SetState(2170)
			p.Opt_nowait()
		}

	case 9:
		p.EnterOuterAlt(localctx, 9)
		{
			p.SetState(2172)
			p.Match(PostgreSQLParserALTER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2173)
			p.Match(PostgreSQLParserFOREIGN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2174)
			p.Match(PostgreSQLParserTABLE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		p.SetState(2177)
		p.GetErrorHandler().Sync(p)

		if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 45, p.GetParserRuleContext()) == 1 {
			{
				p.SetState(2175)
				p.Match(PostgreSQLParserIF_P)
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}
			{
				p.SetState(2176)
				p.Match(PostgreSQLParserEXISTS)
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}

		} else if p.HasError() { // JIM
			goto errorExit
		}
		{
			p.SetState(2179)
			p.Relation_expr()
		}
		{
			p.SetState(2180)
			p.Alter_table_cmds()
		}

	case antlr.ATNInvalidAltNumber:
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IAlter_table_cmdsContext is an interface to support dynamic dispatch.
type IAlter_table_cmdsContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	AllAlter_table_cmd() []IAlter_table_cmdContext
	Alter_table_cmd(i int) IAlter_table_cmdContext
	AllCOMMA() []antlr.TerminalNode
	COMMA(i int) antlr.TerminalNode

	// IsAlter_table_cmdsContext differentiates from other interfaces.
	IsAlter_table_cmdsContext()
}

type Alter_table_cmdsContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyAlter_table_cmdsContext() *Alter_table_cmdsContext {
	var p = new(Alter_table_cmdsContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_alter_table_cmds
	return p
}

func InitEmptyAlter_table_cmdsContext(p *Alter_table_cmdsContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_alter_table_cmds
}

func (*Alter_table_cmdsContext) IsAlter_table_cmdsContext() {}

func NewAlter_table_cmdsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_table_cmdsContext {
	var p = new(Alter_table_cmdsContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_alter_table_cmds

	return p
}

func (s *Alter_table_cmdsContext) GetParser() antlr.Parser { return s.parser }

func (s *Alter_table_cmdsContext) AllAlter_table_cmd() []IAlter_table_cmdContext {
	children := s.GetChildren()
	len := 0
	for _, ctx := range children {
		if _, ok := ctx.(IAlter_table_cmdContext); ok {
			len++
		}
	}

	tst := make([]IAlter_table_cmdContext, len)
	i := 0
	for _, ctx := range children {
		if t, ok := ctx.(IAlter_table_cmdContext); ok {
			tst[i] = t.(IAlter_table_cmdContext)
			i++
		}
	}

	return tst
}

func (s *Alter_table_cmdsContext) Alter_table_cmd(i int) IAlter_table_cmdContext {
	var t antlr.RuleContext
	j := 0
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IAlter_table_cmdContext); ok {
			if j == i {
				t = ctx.(antlr.RuleContext)
				break
			}
			j++
		}
	}

	if t == nil {
		return nil
	}

	return t.(IAlter_table_cmdContext)
}

func (s *Alter_table_cmdsContext) AllCOMMA() []antlr.TerminalNode {
	return s.GetTokens(PostgreSQLParserCOMMA)
}

func (s *Alter_table_cmdsContext) COMMA(i int) antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCOMMA, i)
}

func (s *Alter_table_cmdsContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Alter_table_cmdsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Alter_table_cmdsContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterAlter_table_cmds(s)
	}
}

func (s *Alter_table_cmdsContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitAlter_table_cmds(s)
	}
}

func (s *Alter_table_cmdsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitAlter_table_cmds(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Alter_table_cmds() (localctx IAlter_table_cmdsContext) {
	localctx = NewAlter_table_cmdsContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 98, PostgreSQLParserRULE_alter_table_cmds)
	var _la int

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(2184)
		p.Alter_table_cmd()
	}
	p.SetState(2189)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}
	_la = p.GetTokenStream().LA(1)

	for _la == PostgreSQLParserCOMMA {
		{
			p.SetState(2185)
			p.Match(PostgreSQLParserCOMMA)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2186)
			p.Alter_table_cmd()
		}

		p.SetState(2191)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}
		_la = p.GetTokenStream().LA(1)
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IPartition_cmdContext is an interface to support dynamic dispatch.
type IPartition_cmdContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	ATTACH() antlr.TerminalNode
	PARTITION() antlr.TerminalNode
	Qualified_name() IQualified_nameContext
	Partitionboundspec() IPartitionboundspecContext
	DETACH() antlr.TerminalNode

	// IsPartition_cmdContext differentiates from other interfaces.
	IsPartition_cmdContext()
}

type Partition_cmdContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyPartition_cmdContext() *Partition_cmdContext {
	var p = new(Partition_cmdContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_partition_cmd
	return p
}

func InitEmptyPartition_cmdContext(p *Partition_cmdContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_partition_cmd
}

func (*Partition_cmdContext) IsPartition_cmdContext() {}

func NewPartition_cmdContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Partition_cmdContext {
	var p = new(Partition_cmdContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_partition_cmd

	return p
}

func (s *Partition_cmdContext) GetParser() antlr.Parser { return s.parser }

func (s *Partition_cmdContext) ATTACH() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserATTACH, 0)
}

func (s *Partition_cmdContext) PARTITION() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserPARTITION, 0)
}

func (s *Partition_cmdContext) Qualified_name() IQualified_nameContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IQualified_nameContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IQualified_nameContext)
}

func (s *Partition_cmdContext) Partitionboundspec() IPartitionboundspecContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IPartitionboundspecContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IPartitionboundspecContext)
}

func (s *Partition_cmdContext) DETACH() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserDETACH, 0)
}

func (s *Partition_cmdContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Partition_cmdContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Partition_cmdContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterPartition_cmd(s)
	}
}

func (s *Partition_cmdContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitPartition_cmd(s)
	}
}

func (s *Partition_cmdContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitPartition_cmd(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Partition_cmd() (localctx IPartition_cmdContext) {
	localctx = NewPartition_cmdContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 100, PostgreSQLParserRULE_partition_cmd)
	p.SetState(2200)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetTokenStream().LA(1) {
	case PostgreSQLParserATTACH:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(2192)
			p.Match(PostgreSQLParserATTACH)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2193)
			p.Match(PostgreSQLParserPARTITION)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2194)
			p.Qualified_name()
		}
		{
			p.SetState(2195)
			p.Partitionboundspec()
		}

	case PostgreSQLParserDETACH:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(2197)
			p.Match(PostgreSQLParserDETACH)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2198)
			p.Match(PostgreSQLParserPARTITION)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2199)
			p.Qualified_name()
		}

	default:
		p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IIndex_partition_cmdContext is an interface to support dynamic dispatch.
type IIndex_partition_cmdContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	ATTACH() antlr.TerminalNode
	PARTITION() antlr.TerminalNode
	Qualified_name() IQualified_nameContext

	// IsIndex_partition_cmdContext differentiates from other interfaces.
	IsIndex_partition_cmdContext()
}

type Index_partition_cmdContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyIndex_partition_cmdContext() *Index_partition_cmdContext {
	var p = new(Index_partition_cmdContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_index_partition_cmd
	return p
}

func InitEmptyIndex_partition_cmdContext(p *Index_partition_cmdContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_index_partition_cmd
}

func (*Index_partition_cmdContext) IsIndex_partition_cmdContext() {}

func NewIndex_partition_cmdContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Index_partition_cmdContext {
	var p = new(Index_partition_cmdContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_index_partition_cmd

	return p
}

func (s *Index_partition_cmdContext) GetParser() antlr.Parser { return s.parser }

func (s *Index_partition_cmdContext) ATTACH() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserATTACH, 0)
}

func (s *Index_partition_cmdContext) PARTITION() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserPARTITION, 0)
}

func (s *Index_partition_cmdContext) Qualified_name() IQualified_nameContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IQualified_nameContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IQualified_nameContext)
}

func (s *Index_partition_cmdContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Index_partition_cmdContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Index_partition_cmdContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterIndex_partition_cmd(s)
	}
}

func (s *Index_partition_cmdContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitIndex_partition_cmd(s)
	}
}

func (s *Index_partition_cmdContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitIndex_partition_cmd(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Index_partition_cmd() (localctx IIndex_partition_cmdContext) {
	localctx = NewIndex_partition_cmdContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 102, PostgreSQLParserRULE_index_partition_cmd)
	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(2202)
		p.Match(PostgreSQLParserATTACH)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(2203)
		p.Match(PostgreSQLParserPARTITION)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(2204)
		p.Qualified_name()
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IAlter_table_cmdContext is an interface to support dynamic dispatch.
type IAlter_table_cmdContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	ADD_P() antlr.TerminalNode
	ColumnDef() IColumnDefContext
	IF_P() antlr.TerminalNode
	NOT() antlr.TerminalNode
	EXISTS() antlr.TerminalNode
	COLUMN() antlr.TerminalNode
	ALTER() antlr.TerminalNode
	Opt_column() IOpt_columnContext
	AllColid() []IColidContext
	Colid(i int) IColidContext
	Alter_column_default() IAlter_column_defaultContext
	DROP() antlr.TerminalNode
	NULL_P() antlr.TerminalNode
	SET() antlr.TerminalNode
	EXPRESSION() antlr.TerminalNode
	STATISTICS() antlr.TerminalNode
	Signediconst() ISignediconstContext
	Iconst() IIconstContext
	Reloptions() IReloptionsContext
	RESET() antlr.TerminalNode
	STORAGE() antlr.TerminalNode
	GENERATED() antlr.TerminalNode
	Generated_when() IGenerated_whenContext
	AS() antlr.TerminalNode
	IDENTITY_P() antlr.TerminalNode
	Optparenthesizedseqoptlist() IOptparenthesizedseqoptlistContext
	Alter_identity_column_option_list() IAlter_identity_column_option_listContext
	Opt_drop_behavior() IOpt_drop_behaviorContext
	Opt_set_data() IOpt_set_dataContext
	TYPE_P() antlr.TerminalNode
	Typename() ITypenameContext
	Opt_collate_clause() IOpt_collate_clauseContext
	Alter_using() IAlter_usingContext
	Alter_generic_options() IAlter_generic_optionsContext
	Tableconstraint() ITableconstraintContext
	CONSTRAINT() antlr.TerminalNode
	Name() INameContext
	Constraintattributespec() IConstraintattributespecContext
	VALIDATE() antlr.TerminalNode
	WITHOUT() antlr.TerminalNode
	OIDS() antlr.TerminalNode
	CLUSTER() antlr.TerminalNode
	ON() antlr.TerminalNode
	LOGGED() antlr.TerminalNode
	UNLOGGED() antlr.TerminalNode
	ENABLE_P() antlr.TerminalNode
	TRIGGER() antlr.TerminalNode
	ALWAYS() antlr.TerminalNode
	REPLICA() antlr.TerminalNode
	ALL() antlr.TerminalNode
	USER() antlr.TerminalNode
	DISABLE_P() antlr.TerminalNode
	RULE() antlr.TerminalNode
	INHERIT() antlr.TerminalNode
	Qualified_name() IQualified_nameContext
	NO() antlr.TerminalNode
	OF() antlr.TerminalNode
	Any_name() IAny_nameContext
	OWNER() antlr.TerminalNode
	TO() antlr.TerminalNode
	Rolespec() IRolespecContext
	TABLESPACE() antlr.TerminalNode
	Replica_identity() IReplica_identityContext
	ROW() antlr.TerminalNode
	LEVEL() antlr.TerminalNode
	SECURITY() antlr.TerminalNode
	FORCE() antlr.TerminalNode

	// IsAlter_table_cmdContext differentiates from other interfaces.
	IsAlter_table_cmdContext()
}

type Alter_table_cmdContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyAlter_table_cmdContext() *Alter_table_cmdContext {
	var p = new(Alter_table_cmdContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_alter_table_cmd
	return p
}

func InitEmptyAlter_table_cmdContext(p *Alter_table_cmdContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_alter_table_cmd
}

func (*Alter_table_cmdContext) IsAlter_table_cmdContext() {}

func NewAlter_table_cmdContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_table_cmdContext {
	var p = new(Alter_table_cmdContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_alter_table_cmd

	return p
}

func (s *Alter_table_cmdContext) GetParser() antlr.Parser { return s.parser }

func (s *Alter_table_cmdContext) ADD_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserADD_P, 0)
}

func (s *Alter_table_cmdContext) ColumnDef() IColumnDefContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IColumnDefContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IColumnDefContext)
}

func (s *Alter_table_cmdContext) IF_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserIF_P, 0)
}

func (s *Alter_table_cmdContext) NOT() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserNOT, 0)
}

func (s *Alter_table_cmdContext) EXISTS() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserEXISTS, 0)
}

func (s *Alter_table_cmdContext) COLUMN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCOLUMN, 0)
}

func (s *Alter_table_cmdContext) ALTER() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserALTER, 0)
}

func (s *Alter_table_cmdContext) Opt_column() IOpt_columnContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOpt_columnContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOpt_columnContext)
}

func (s *Alter_table_cmdContext) AllColid() []IColidContext {
	children := s.GetChildren()
	len := 0
	for _, ctx := range children {
		if _, ok := ctx.(IColidContext); ok {
			len++
		}
	}

	tst := make([]IColidContext, len)
	i := 0
	for _, ctx := range children {
		if t, ok := ctx.(IColidContext); ok {
			tst[i] = t.(IColidContext)
			i++
		}
	}

	return tst
}

func (s *Alter_table_cmdContext) Colid(i int) IColidContext {
	var t antlr.RuleContext
	j := 0
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IColidContext); ok {
			if j == i {
				t = ctx.(antlr.RuleContext)
				break
			}
			j++
		}
	}

	if t == nil {
		return nil
	}

	return t.(IColidContext)
}

func (s *Alter_table_cmdContext) Alter_column_default() IAlter_column_defaultContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IAlter_column_defaultContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IAlter_column_defaultContext)
}

func (s *Alter_table_cmdContext) DROP() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserDROP, 0)
}

func (s *Alter_table_cmdContext) NULL_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserNULL_P, 0)
}

func (s *Alter_table_cmdContext) SET() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserSET, 0)
}

func (s *Alter_table_cmdContext) EXPRESSION() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserEXPRESSION, 0)
}

func (s *Alter_table_cmdContext) STATISTICS() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserSTATISTICS, 0)
}

func (s *Alter_table_cmdContext) Signediconst() ISignediconstContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ISignediconstContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ISignediconstContext)
}

func (s *Alter_table_cmdContext) Iconst() IIconstContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IIconstContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IIconstContext)
}

func (s *Alter_table_cmdContext) Reloptions() IReloptionsContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IReloptionsContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IReloptionsContext)
}

func (s *Alter_table_cmdContext) RESET() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserRESET, 0)
}

func (s *Alter_table_cmdContext) STORAGE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserSTORAGE, 0)
}

func (s *Alter_table_cmdContext) GENERATED() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserGENERATED, 0)
}

func (s *Alter_table_cmdContext) Generated_when() IGenerated_whenContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IGenerated_whenContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IGenerated_whenContext)
}

func (s *Alter_table_cmdContext) AS() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserAS, 0)
}

func (s *Alter_table_cmdContext) IDENTITY_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserIDENTITY_P, 0)
}

func (s *Alter_table_cmdContext) Optparenthesizedseqoptlist() IOptparenthesizedseqoptlistContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOptparenthesizedseqoptlistContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOptparenthesizedseqoptlistContext)
}

func (s *Alter_table_cmdContext) Alter_identity_column_option_list() IAlter_identity_column_option_listContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IAlter_identity_column_option_listContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IAlter_identity_column_option_listContext)
}

func (s *Alter_table_cmdContext) Opt_drop_behavior() IOpt_drop_behaviorContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOpt_drop_behaviorContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOpt_drop_behaviorContext)
}

func (s *Alter_table_cmdContext) Opt_set_data() IOpt_set_dataContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOpt_set_dataContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOpt_set_dataContext)
}

func (s *Alter_table_cmdContext) TYPE_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserTYPE_P, 0)
}

func (s *Alter_table_cmdContext) Typename() ITypenameContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ITypenameContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ITypenameContext)
}

func (s *Alter_table_cmdContext) Opt_collate_clause() IOpt_collate_clauseContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOpt_collate_clauseContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOpt_collate_clauseContext)
}

func (s *Alter_table_cmdContext) Alter_using() IAlter_usingContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IAlter_usingContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IAlter_usingContext)
}

func (s *Alter_table_cmdContext) Alter_generic_options() IAlter_generic_optionsContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IAlter_generic_optionsContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IAlter_generic_optionsContext)
}

func (s *Alter_table_cmdContext) Tableconstraint() ITableconstraintContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ITableconstraintContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ITableconstraintContext)
}

func (s *Alter_table_cmdContext) CONSTRAINT() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCONSTRAINT, 0)
}

func (s *Alter_table_cmdContext) Name() INameContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(INameContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(INameContext)
}

func (s *Alter_table_cmdContext) Constraintattributespec() IConstraintattributespecContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IConstraintattributespecContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IConstraintattributespecContext)
}

func (s *Alter_table_cmdContext) VALIDATE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserVALIDATE, 0)
}

func (s *Alter_table_cmdContext) WITHOUT() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserWITHOUT, 0)
}

func (s *Alter_table_cmdContext) OIDS() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserOIDS, 0)
}

func (s *Alter_table_cmdContext) CLUSTER() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCLUSTER, 0)
}

func (s *Alter_table_cmdContext) ON() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserON, 0)
}

func (s *Alter_table_cmdContext) LOGGED() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserLOGGED, 0)
}

func (s *Alter_table_cmdContext) UNLOGGED() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserUNLOGGED, 0)
}

func (s *Alter_table_cmdContext) ENABLE_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserENABLE_P, 0)
}

func (s *Alter_table_cmdContext) TRIGGER() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserTRIGGER, 0)
}

func (s *Alter_table_cmdContext) ALWAYS() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserALWAYS, 0)
}

func (s *Alter_table_cmdContext) REPLICA() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserREPLICA, 0)
}

func (s *Alter_table_cmdContext) ALL() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserALL, 0)
}

func (s *Alter_table_cmdContext) USER() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserUSER, 0)
}

func (s *Alter_table_cmdContext) DISABLE_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserDISABLE_P, 0)
}

func (s *Alter_table_cmdContext) RULE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserRULE, 0)
}

func (s *Alter_table_cmdContext) INHERIT() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserINHERIT, 0)
}

func (s *Alter_table_cmdContext) Qualified_name() IQualified_nameContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IQualified_nameContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IQualified_nameContext)
}

func (s *Alter_table_cmdContext) NO() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserNO, 0)
}

func (s *Alter_table_cmdContext) OF() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserOF, 0)
}

func (s *Alter_table_cmdContext) Any_name() IAny_nameContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IAny_nameContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IAny_nameContext)
}

func (s *Alter_table_cmdContext) OWNER() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserOWNER, 0)
}

func (s *Alter_table_cmdContext) TO() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserTO, 0)
}

func (s *Alter_table_cmdContext) Rolespec() IRolespecContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IRolespecContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IRolespecContext)
}

func (s *Alter_table_cmdContext) TABLESPACE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserTABLESPACE, 0)
}

func (s *Alter_table_cmdContext) Replica_identity() IReplica_identityContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IReplica_identityContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IReplica_identityContext)
}

func (s *Alter_table_cmdContext) ROW() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserROW, 0)
}

func (s *Alter_table_cmdContext) LEVEL() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserLEVEL, 0)
}

func (s *Alter_table_cmdContext) SECURITY() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserSECURITY, 0)
}

func (s *Alter_table_cmdContext) FORCE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserFORCE, 0)
}

func (s *Alter_table_cmdContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Alter_table_cmdContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Alter_table_cmdContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterAlter_table_cmd(s)
	}
}

func (s *Alter_table_cmdContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitAlter_table_cmd(s)
	}
}

func (s *Alter_table_cmdContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitAlter_table_cmd(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Alter_table_cmd() (localctx IAlter_table_cmdContext) {
	localctx = NewAlter_table_cmdContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 104, PostgreSQLParserRULE_alter_table_cmd)
	p.SetState(2458)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 49, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(2206)
			p.Match(PostgreSQLParserADD_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2207)
			p.ColumnDef()
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(2208)
			p.Match(PostgreSQLParserADD_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2209)
			p.Match(PostgreSQLParserIF_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2210)
			p.Match(PostgreSQLParserNOT)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2211)
			p.Match(PostgreSQLParserEXISTS)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2212)
			p.ColumnDef()
		}

	case 3:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(2213)
			p.Match(PostgreSQLParserADD_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2214)
			p.Match(PostgreSQLParserCOLUMN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2215)
			p.ColumnDef()
		}

	case 4:
		p.EnterOuterAlt(localctx, 4)
		{
			p.SetState(2216)
			p.Match(PostgreSQLParserADD_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2217)
			p.Match(PostgreSQLParserCOLUMN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2218)
			p.Match(PostgreSQLParserIF_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2219)
			p.Match(PostgreSQLParserNOT)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2220)
			p.Match(PostgreSQLParserEXISTS)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2221)
			p.ColumnDef()
		}

	case 5:
		p.EnterOuterAlt(localctx, 5)
		{
			p.SetState(2222)
			p.Match(PostgreSQLParserALTER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2223)
			p.Opt_column()
		}
		{
			p.SetState(2224)
			p.Colid()
		}
		{
			p.SetState(2225)
			p.Alter_column_default()
		}

	case 6:
		p.EnterOuterAlt(localctx, 6)
		{
			p.SetState(2227)
			p.Match(PostgreSQLParserALTER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2228)
			p.Opt_column()
		}
		{
			p.SetState(2229)
			p.Colid()
		}
		{
			p.SetState(2230)
			p.Match(PostgreSQLParserDROP)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2231)
			p.Match(PostgreSQLParserNOT)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2232)
			p.Match(PostgreSQLParserNULL_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 7:
		p.EnterOuterAlt(localctx, 7)
		{
			p.SetState(2234)
			p.Match(PostgreSQLParserALTER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2235)
			p.Opt_column()
		}
		{
			p.SetState(2236)
			p.Colid()
		}
		{
			p.SetState(2237)
			p.Match(PostgreSQLParserSET)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2238)
			p.Match(PostgreSQLParserNOT)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2239)
			p.Match(PostgreSQLParserNULL_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 8:
		p.EnterOuterAlt(localctx, 8)
		{
			p.SetState(2241)
			p.Match(PostgreSQLParserALTER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2242)
			p.Opt_column()
		}
		{
			p.SetState(2243)
			p.Colid()
		}
		{
			p.SetState(2244)
			p.Match(PostgreSQLParserDROP)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2245)
			p.Match(PostgreSQLParserEXPRESSION)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 9:
		p.EnterOuterAlt(localctx, 9)
		{
			p.SetState(2247)
			p.Match(PostgreSQLParserALTER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2248)
			p.Opt_column()
		}
		{
			p.SetState(2249)
			p.Colid()
		}
		{
			p.SetState(2250)
			p.Match(PostgreSQLParserDROP)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2251)
			p.Match(PostgreSQLParserEXPRESSION)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2252)
			p.Match(PostgreSQLParserIF_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2253)
			p.Match(PostgreSQLParserEXISTS)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 10:
		p.EnterOuterAlt(localctx, 10)
		{
			p.SetState(2255)
			p.Match(PostgreSQLParserALTER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2256)
			p.Opt_column()
		}
		{
			p.SetState(2257)
			p.Colid()
		}
		{
			p.SetState(2258)
			p.Match(PostgreSQLParserSET)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2259)
			p.Match(PostgreSQLParserSTATISTICS)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2260)
			p.Signediconst()
		}

	case 11:
		p.EnterOuterAlt(localctx, 11)
		{
			p.SetState(2262)
			p.Match(PostgreSQLParserALTER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2263)
			p.Opt_column()
		}
		{
			p.SetState(2264)
			p.Iconst()
		}
		{
			p.SetState(2265)
			p.Match(PostgreSQLParserSET)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2266)
			p.Match(PostgreSQLParserSTATISTICS)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2267)
			p.Signediconst()
		}

	case 12:
		p.EnterOuterAlt(localctx, 12)
		{
			p.SetState(2269)
			p.Match(PostgreSQLParserALTER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2270)
			p.Opt_column()
		}
		{
			p.SetState(2271)
			p.Colid()
		}
		{
			p.SetState(2272)
			p.Match(PostgreSQLParserSET)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2273)
			p.Reloptions()
		}

	case 13:
		p.EnterOuterAlt(localctx, 13)
		{
			p.SetState(2275)
			p.Match(PostgreSQLParserALTER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2276)
			p.Opt_column()
		}
		{
			p.SetState(2277)
			p.Colid()
		}
		{
			p.SetState(2278)
			p.Match(PostgreSQLParserRESET)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2279)
			p.Reloptions()
		}

	case 14:
		p.EnterOuterAlt(localctx, 14)
		{
			p.SetState(2281)
			p.Match(PostgreSQLParserALTER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2282)
			p.Opt_column()
		}
		{
			p.SetState(2283)
			p.Colid()
		}
		{
			p.SetState(2284)
			p.Match(PostgreSQLParserSET)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2285)
			p.Match(PostgreSQLParserSTORAGE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2286)
			p.Colid()
		}

	case 15:
		p.EnterOuterAlt(localctx, 15)
		{
			p.SetState(2288)
			p.Match(PostgreSQLParserALTER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2289)
			p.Opt_column()
		}
		{
			p.SetState(2290)
			p.Colid()
		}
		{
			p.SetState(2291)
			p.Match(PostgreSQLParserADD_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2292)
			p.Match(PostgreSQLParserGENERATED)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2293)
			p.Generated_when()
		}
		{
			p.SetState(2294)
			p.Match(PostgreSQLParserAS)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2295)
			p.Match(PostgreSQLParserIDENTITY_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2296)
			p.Optparenthesizedseqoptlist()
		}

	case 16:
		p.EnterOuterAlt(localctx, 16)
		{
			p.SetState(2298)
			p.Match(PostgreSQLParserALTER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2299)
			p.Opt_column()
		}
		{
			p.SetState(2300)
			p.Colid()
		}
		{
			p.SetState(2301)
			p.Alter_identity_column_option_list()
		}

	case 17:
		p.EnterOuterAlt(localctx, 17)
		{
			p.SetState(2303)
			p.Match(PostgreSQLParserALTER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2304)
			p.Opt_column()
		}
		{
			p.SetState(2305)
			p.Colid()
		}
		{
			p.SetState(2306)
			p.Match(PostgreSQLParserDROP)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2307)
			p.Match(PostgreSQLParserIDENTITY_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 18:
		p.EnterOuterAlt(localctx, 18)
		{
			p.SetState(2309)
			p.Match(PostgreSQLParserALTER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2310)
			p.Opt_column()
		}
		{
			p.SetState(2311)
			p.Colid()
		}
		{
			p.SetState(2312)
			p.Match(PostgreSQLParserDROP)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2313)
			p.Match(PostgreSQLParserIDENTITY_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2314)
			p.Match(PostgreSQLParserIF_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2315)
			p.Match(PostgreSQLParserEXISTS)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 19:
		p.EnterOuterAlt(localctx, 19)
		{
			p.SetState(2317)
			p.Match(PostgreSQLParserDROP)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2318)
			p.Opt_column()
		}
		{
			p.SetState(2319)
			p.Match(PostgreSQLParserIF_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2320)
			p.Match(PostgreSQLParserEXISTS)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2321)
			p.Colid()
		}
		{
			p.SetState(2322)
			p.Opt_drop_behavior()
		}

	case 20:
		p.EnterOuterAlt(localctx, 20)
		{
			p.SetState(2324)
			p.Match(PostgreSQLParserDROP)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2325)
			p.Opt_column()
		}
		{
			p.SetState(2326)
			p.Colid()
		}
		{
			p.SetState(2327)
			p.Opt_drop_behavior()
		}

	case 21:
		p.EnterOuterAlt(localctx, 21)
		{
			p.SetState(2329)
			p.Match(PostgreSQLParserALTER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2330)
			p.Opt_column()
		}
		{
			p.SetState(2331)
			p.Colid()
		}
		{
			p.SetState(2332)
			p.Opt_set_data()
		}
		{
			p.SetState(2333)
			p.Match(PostgreSQLParserTYPE_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2334)
			p.Typename()
		}
		{
			p.SetState(2335)
			p.Opt_collate_clause()
		}
		{
			p.SetState(2336)
			p.Alter_using()
		}

	case 22:
		p.EnterOuterAlt(localctx, 22)
		{
			p.SetState(2338)
			p.Match(PostgreSQLParserALTER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2339)
			p.Opt_column()
		}
		{
			p.SetState(2340)
			p.Colid()
		}
		{
			p.SetState(2341)
			p.Alter_generic_options()
		}

	case 23:
		p.EnterOuterAlt(localctx, 23)
		{
			p.SetState(2343)
			p.Match(PostgreSQLParserADD_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2344)
			p.Tableconstraint()
		}

	case 24:
		p.EnterOuterAlt(localctx, 24)
		{
			p.SetState(2345)
			p.Match(PostgreSQLParserALTER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2346)
			p.Match(PostgreSQLParserCONSTRAINT)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2347)
			p.Name()
		}
		{
			p.SetState(2348)
			p.Constraintattributespec()
		}

	case 25:
		p.EnterOuterAlt(localctx, 25)
		{
			p.SetState(2350)
			p.Match(PostgreSQLParserVALIDATE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2351)
			p.Match(PostgreSQLParserCONSTRAINT)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2352)
			p.Name()
		}

	case 26:
		p.EnterOuterAlt(localctx, 26)
		{
			p.SetState(2353)
			p.Match(PostgreSQLParserDROP)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2354)
			p.Match(PostgreSQLParserCONSTRAINT)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2355)
			p.Match(PostgreSQLParserIF_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2356)
			p.Match(PostgreSQLParserEXISTS)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2357)
			p.Name()
		}
		{
			p.SetState(2358)
			p.Opt_drop_behavior()
		}

	case 27:
		p.EnterOuterAlt(localctx, 27)
		{
			p.SetState(2360)
			p.Match(PostgreSQLParserDROP)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2361)
			p.Match(PostgreSQLParserCONSTRAINT)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2362)
			p.Name()
		}
		{
			p.SetState(2363)
			p.Opt_drop_behavior()
		}

	case 28:
		p.EnterOuterAlt(localctx, 28)
		{
			p.SetState(2365)
			p.Match(PostgreSQLParserSET)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2366)
			p.Match(PostgreSQLParserWITHOUT)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2367)
			p.Match(PostgreSQLParserOIDS)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 29:
		p.EnterOuterAlt(localctx, 29)
		{
			p.SetState(2368)
			p.Match(PostgreSQLParserCLUSTER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2369)
			p.Match(PostgreSQLParserON)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2370)
			p.Name()
		}

	case 30:
		p.EnterOuterAlt(localctx, 30)
		{
			p.SetState(2371)
			p.Match(PostgreSQLParserSET)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2372)
			p.Match(PostgreSQLParserWITHOUT)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2373)
			p.Match(PostgreSQLParserCLUSTER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 31:
		p.EnterOuterAlt(localctx, 31)
		{
			p.SetState(2374)
			p.Match(PostgreSQLParserSET)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2375)
			p.Match(PostgreSQLParserLOGGED)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 32:
		p.EnterOuterAlt(localctx, 32)
		{
			p.SetState(2376)
			p.Match(PostgreSQLParserSET)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2377)
			p.Match(PostgreSQLParserUNLOGGED)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 33:
		p.EnterOuterAlt(localctx, 33)
		{
			p.SetState(2378)
			p.Match(PostgreSQLParserENABLE_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2379)
			p.Match(PostgreSQLParserTRIGGER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2380)
			p.Name()
		}

	case 34:
		p.EnterOuterAlt(localctx, 34)
		{
			p.SetState(2381)
			p.Match(PostgreSQLParserENABLE_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2382)
			p.Match(PostgreSQLParserALWAYS)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2383)
			p.Match(PostgreSQLParserTRIGGER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2384)
			p.Name()
		}

	case 35:
		p.EnterOuterAlt(localctx, 35)
		{
			p.SetState(2385)
			p.Match(PostgreSQLParserENABLE_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2386)
			p.Match(PostgreSQLParserREPLICA)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2387)
			p.Match(PostgreSQLParserTRIGGER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2388)
			p.Name()
		}

	case 36:
		p.EnterOuterAlt(localctx, 36)
		{
			p.SetState(2389)
			p.Match(PostgreSQLParserENABLE_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2390)
			p.Match(PostgreSQLParserTRIGGER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2391)
			p.Match(PostgreSQLParserALL)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 37:
		p.EnterOuterAlt(localctx, 37)
		{
			p.SetState(2392)
			p.Match(PostgreSQLParserENABLE_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2393)
			p.Match(PostgreSQLParserTRIGGER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2394)
			p.Match(PostgreSQLParserUSER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 38:
		p.EnterOuterAlt(localctx, 38)
		{
			p.SetState(2395)
			p.Match(PostgreSQLParserDISABLE_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2396)
			p.Match(PostgreSQLParserTRIGGER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2397)
			p.Name()
		}

	case 39:
		p.EnterOuterAlt(localctx, 39)
		{
			p.SetState(2398)
			p.Match(PostgreSQLParserDISABLE_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2399)
			p.Match(PostgreSQLParserTRIGGER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2400)
			p.Match(PostgreSQLParserALL)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 40:
		p.EnterOuterAlt(localctx, 40)
		{
			p.SetState(2401)
			p.Match(PostgreSQLParserDISABLE_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2402)
			p.Match(PostgreSQLParserTRIGGER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2403)
			p.Match(PostgreSQLParserUSER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 41:
		p.EnterOuterAlt(localctx, 41)
		{
			p.SetState(2404)
			p.Match(PostgreSQLParserENABLE_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2405)
			p.Match(PostgreSQLParserRULE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2406)
			p.Name()
		}

	case 42:
		p.EnterOuterAlt(localctx, 42)
		{
			p.SetState(2407)
			p.Match(PostgreSQLParserENABLE_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2408)
			p.Match(PostgreSQLParserALWAYS)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2409)
			p.Match(PostgreSQLParserRULE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2410)
			p.Name()
		}

	case 43:
		p.EnterOuterAlt(localctx, 43)
		{
			p.SetState(2411)
			p.Match(PostgreSQLParserENABLE_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2412)
			p.Match(PostgreSQLParserREPLICA)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2413)
			p.Match(PostgreSQLParserRULE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2414)
			p.Name()
		}

	case 44:
		p.EnterOuterAlt(localctx, 44)
		{
			p.SetState(2415)
			p.Match(PostgreSQLParserDISABLE_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2416)
			p.Match(PostgreSQLParserRULE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2417)
			p.Name()
		}

	case 45:
		p.EnterOuterAlt(localctx, 45)
		{
			p.SetState(2418)
			p.Match(PostgreSQLParserINHERIT)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2419)
			p.Qualified_name()
		}

	case 46:
		p.EnterOuterAlt(localctx, 46)
		{
			p.SetState(2420)
			p.Match(PostgreSQLParserNO)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2421)
			p.Match(PostgreSQLParserINHERIT)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2422)
			p.Qualified_name()
		}

	case 47:
		p.EnterOuterAlt(localctx, 47)
		{
			p.SetState(2423)
			p.Match(PostgreSQLParserOF)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2424)
			p.Any_name()
		}

	case 48:
		p.EnterOuterAlt(localctx, 48)
		{
			p.SetState(2425)
			p.Match(PostgreSQLParserNOT)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2426)
			p.Match(PostgreSQLParserOF)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 49:
		p.EnterOuterAlt(localctx, 49)
		{
			p.SetState(2427)
			p.Match(PostgreSQLParserOWNER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2428)
			p.Match(PostgreSQLParserTO)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2429)
			p.Rolespec()
		}

	case 50:
		p.EnterOuterAlt(localctx, 50)
		{
			p.SetState(2430)
			p.Match(PostgreSQLParserSET)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2431)
			p.Match(PostgreSQLParserTABLESPACE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2432)
			p.Name()
		}

	case 51:
		p.EnterOuterAlt(localctx, 51)
		{
			p.SetState(2433)
			p.Match(PostgreSQLParserSET)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2434)
			p.Reloptions()
		}

	case 52:
		p.EnterOuterAlt(localctx, 52)
		{
			p.SetState(2435)
			p.Match(PostgreSQLParserRESET)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2436)
			p.Reloptions()
		}

	case 53:
		p.EnterOuterAlt(localctx, 53)
		{
			p.SetState(2437)
			p.Match(PostgreSQLParserREPLICA)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2438)
			p.Match(PostgreSQLParserIDENTITY_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2439)
			p.Replica_identity()
		}

	case 54:
		p.EnterOuterAlt(localctx, 54)
		{
			p.SetState(2440)
			p.Match(PostgreSQLParserENABLE_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2441)
			p.Match(PostgreSQLParserROW)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2442)
			p.Match(PostgreSQLParserLEVEL)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2443)
			p.Match(PostgreSQLParserSECURITY)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 55:
		p.EnterOuterAlt(localctx, 55)
		{
			p.SetState(2444)
			p.Match(PostgreSQLParserDISABLE_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2445)
			p.Match(PostgreSQLParserROW)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2446)
			p.Match(PostgreSQLParserLEVEL)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2447)
			p.Match(PostgreSQLParserSECURITY)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 56:
		p.EnterOuterAlt(localctx, 56)
		{
			p.SetState(2448)
			p.Match(PostgreSQLParserFORCE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2449)
			p.Match(PostgreSQLParserROW)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2450)
			p.Match(PostgreSQLParserLEVEL)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2451)
			p.Match(PostgreSQLParserSECURITY)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 57:
		p.EnterOuterAlt(localctx, 57)
		{
			p.SetState(2452)
			p.Match(PostgreSQLParserNO)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2453)
			p.Match(PostgreSQLParserFORCE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2454)
			p.Match(PostgreSQLParserROW)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2455)
			p.Match(PostgreSQLParserLEVEL)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2456)
			p.Match(PostgreSQLParserSECURITY)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 58:
		p.EnterOuterAlt(localctx, 58)
		{
			p.SetState(2457)
			p.Alter_generic_options()
		}

	case antlr.ATNInvalidAltNumber:
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IAlter_column_defaultContext is an interface to support dynamic dispatch.
type IAlter_column_defaultContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	SET() antlr.TerminalNode
	DEFAULT() antlr.TerminalNode
	A_expr() IA_exprContext
	DROP() antlr.TerminalNode

	// IsAlter_column_defaultContext differentiates from other interfaces.
	IsAlter_column_defaultContext()
}

type Alter_column_defaultContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyAlter_column_defaultContext() *Alter_column_defaultContext {
	var p = new(Alter_column_defaultContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_alter_column_default
	return p
}

func InitEmptyAlter_column_defaultContext(p *Alter_column_defaultContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_alter_column_default
}

func (*Alter_column_defaultContext) IsAlter_column_defaultContext() {}

func NewAlter_column_defaultContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_column_defaultContext {
	var p = new(Alter_column_defaultContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_alter_column_default

	return p
}

func (s *Alter_column_defaultContext) GetParser() antlr.Parser { return s.parser }

func (s *Alter_column_defaultContext) SET() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserSET, 0)
}

func (s *Alter_column_defaultContext) DEFAULT() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserDEFAULT, 0)
}

func (s *Alter_column_defaultContext) A_expr() IA_exprContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IA_exprContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IA_exprContext)
}

func (s *Alter_column_defaultContext) DROP() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserDROP, 0)
}

func (s *Alter_column_defaultContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Alter_column_defaultContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Alter_column_defaultContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterAlter_column_default(s)
	}
}

func (s *Alter_column_defaultContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitAlter_column_default(s)
	}
}

func (s *Alter_column_defaultContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitAlter_column_default(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Alter_column_default() (localctx IAlter_column_defaultContext) {
	localctx = NewAlter_column_defaultContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 106, PostgreSQLParserRULE_alter_column_default)
	p.SetState(2465)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetTokenStream().LA(1) {
	case PostgreSQLParserSET:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(2460)
			p.Match(PostgreSQLParserSET)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2461)
			p.Match(PostgreSQLParserDEFAULT)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2462)
			p.A_expr()
		}

	case PostgreSQLParserDROP:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(2463)
			p.Match(PostgreSQLParserDROP)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2464)
			p.Match(PostgreSQLParserDEFAULT)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	default:
		p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IOpt_drop_behaviorContext is an interface to support dynamic dispatch.
type IOpt_drop_behaviorContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	CASCADE() antlr.TerminalNode
	RESTRICT() antlr.TerminalNode

	// IsOpt_drop_behaviorContext differentiates from other interfaces.
	IsOpt_drop_behaviorContext()
}

type Opt_drop_behaviorContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyOpt_drop_behaviorContext() *Opt_drop_behaviorContext {
	var p = new(Opt_drop_behaviorContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opt_drop_behavior
	return p
}

func InitEmptyOpt_drop_behaviorContext(p *Opt_drop_behaviorContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opt_drop_behavior
}

func (*Opt_drop_behaviorContext) IsOpt_drop_behaviorContext() {}

func NewOpt_drop_behaviorContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_drop_behaviorContext {
	var p = new(Opt_drop_behaviorContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_opt_drop_behavior

	return p
}

func (s *Opt_drop_behaviorContext) GetParser() antlr.Parser { return s.parser }

func (s *Opt_drop_behaviorContext) CASCADE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCASCADE, 0)
}

func (s *Opt_drop_behaviorContext) RESTRICT() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserRESTRICT, 0)
}

func (s *Opt_drop_behaviorContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Opt_drop_behaviorContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Opt_drop_behaviorContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterOpt_drop_behavior(s)
	}
}

func (s *Opt_drop_behaviorContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitOpt_drop_behavior(s)
	}
}

func (s *Opt_drop_behaviorContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitOpt_drop_behavior(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Opt_drop_behavior() (localctx IOpt_drop_behaviorContext) {
	localctx = NewOpt_drop_behaviorContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 108, PostgreSQLParserRULE_opt_drop_behavior)
	p.SetState(2470)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetTokenStream().LA(1) {
	case PostgreSQLParserCASCADE:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(2467)
			p.Match(PostgreSQLParserCASCADE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case PostgreSQLParserRESTRICT:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(2468)
			p.Match(PostgreSQLParserRESTRICT)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case PostgreSQLParserEOF, PostgreSQLParserOPEN_PAREN, PostgreSQLParserCOMMA, PostgreSQLParserSEMI, PostgreSQLParserANALYSE, PostgreSQLParserANALYZE, PostgreSQLParserCREATE, PostgreSQLParserDO, PostgreSQLParserFETCH, PostgreSQLParserGRANT, PostgreSQLParserINTO, PostgreSQLParserSELECT, PostgreSQLParserTABLE, PostgreSQLParserWITH, PostgreSQLParserABORT_P, PostgreSQLParserALTER, PostgreSQLParserBEGIN_P, PostgreSQLParserCHECKPOINT, PostgreSQLParserCLOSE, PostgreSQLParserCLUSTER, PostgreSQLParserCOMMENT, PostgreSQLParserCOMMIT, PostgreSQLParserCOPY, PostgreSQLParserDEALLOCATE, PostgreSQLParserDECLARE, PostgreSQLParserDELETE_P, PostgreSQLParserDISCARD, PostgreSQLParserDROP, PostgreSQLParserEXECUTE, PostgreSQLParserEXPLAIN, PostgreSQLParserINSERT, PostgreSQLParserLISTEN, PostgreSQLParserLOAD, PostgreSQLParserLOCK_P, PostgreSQLParserMERGE, PostgreSQLParserMOVE, PostgreSQLParserNOTIFY, PostgreSQLParserPREPARE, PostgreSQLParserREASSIGN, PostgreSQLParserREFRESH, PostgreSQLParserREINDEX, PostgreSQLParserRELEASE, PostgreSQLParserRESET, PostgreSQLParserREVOKE, PostgreSQLParserROLLBACK, PostgreSQLParserSAVEPOINT, PostgreSQLParserSECURITY, PostgreSQLParserSET, PostgreSQLParserSHOW, PostgreSQLParserSTART, PostgreSQLParserTRUNCATE, PostgreSQLParserUNLISTEN, PostgreSQLParserUPDATE, PostgreSQLParserVACUUM, PostgreSQLParserVALUES, PostgreSQLParserCALL, PostgreSQLParserIMPORT_P, PostgreSQLParserEND_P, PostgreSQLParserMetaCommand:
		p.EnterOuterAlt(localctx, 3)

	default:
		p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IOpt_collate_clauseContext is an interface to support dynamic dispatch.
type IOpt_collate_clauseContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	COLLATE() antlr.TerminalNode
	Any_name() IAny_nameContext

	// IsOpt_collate_clauseContext differentiates from other interfaces.
	IsOpt_collate_clauseContext()
}

type Opt_collate_clauseContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyOpt_collate_clauseContext() *Opt_collate_clauseContext {
	var p = new(Opt_collate_clauseContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opt_collate_clause
	return p
}

func InitEmptyOpt_collate_clauseContext(p *Opt_collate_clauseContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opt_collate_clause
}

func (*Opt_collate_clauseContext) IsOpt_collate_clauseContext() {}

func NewOpt_collate_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_collate_clauseContext {
	var p = new(Opt_collate_clauseContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_opt_collate_clause

	return p
}

func (s *Opt_collate_clauseContext) GetParser() antlr.Parser { return s.parser }

func (s *Opt_collate_clauseContext) COLLATE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCOLLATE, 0)
}

func (s *Opt_collate_clauseContext) Any_name() IAny_nameContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IAny_nameContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IAny_nameContext)
}

func (s *Opt_collate_clauseContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Opt_collate_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Opt_collate_clauseContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterOpt_collate_clause(s)
	}
}

func (s *Opt_collate_clauseContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitOpt_collate_clause(s)
	}
}

func (s *Opt_collate_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitOpt_collate_clause(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Opt_collate_clause() (localctx IOpt_collate_clauseContext) {
	localctx = NewOpt_collate_clauseContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 110, PostgreSQLParserRULE_opt_collate_clause)
	p.SetState(2475)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetTokenStream().LA(1) {
	case PostgreSQLParserCOLLATE:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(2472)
			p.Match(PostgreSQLParserCOLLATE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2473)
			p.Any_name()
		}

	case PostgreSQLParserEOF, PostgreSQLParserOPEN_PAREN, PostgreSQLParserCLOSE_PAREN, PostgreSQLParserCOMMA, PostgreSQLParserSEMI, PostgreSQLParserANALYSE, PostgreSQLParserANALYZE, PostgreSQLParserCREATE, PostgreSQLParserDO, PostgreSQLParserFETCH, PostgreSQLParserGRANT, PostgreSQLParserINTO, PostgreSQLParserSELECT, PostgreSQLParserTABLE, PostgreSQLParserUSING, PostgreSQLParserWITH, PostgreSQLParserABORT_P, PostgreSQLParserALTER, PostgreSQLParserBEGIN_P, PostgreSQLParserCASCADE, PostgreSQLParserCHECKPOINT, PostgreSQLParserCLOSE, PostgreSQLParserCLUSTER, PostgreSQLParserCOMMENT, PostgreSQLParserCOMMIT, PostgreSQLParserCOPY, PostgreSQLParserDEALLOCATE, PostgreSQLParserDECLARE, PostgreSQLParserDELETE_P, PostgreSQLParserDISCARD, PostgreSQLParserDROP, PostgreSQLParserEXECUTE, PostgreSQLParserEXPLAIN, PostgreSQLParserINSERT, PostgreSQLParserLISTEN, PostgreSQLParserLOAD, PostgreSQLParserLOCK_P, PostgreSQLParserMERGE, PostgreSQLParserMOVE, PostgreSQLParserNOTIFY, PostgreSQLParserPREPARE, PostgreSQLParserREASSIGN, PostgreSQLParserREFRESH, PostgreSQLParserREINDEX, PostgreSQLParserRELEASE, PostgreSQLParserRESET, PostgreSQLParserRESTRICT, PostgreSQLParserREVOKE, PostgreSQLParserROLLBACK, PostgreSQLParserSAVEPOINT, PostgreSQLParserSECURITY, PostgreSQLParserSET, PostgreSQLParserSHOW, PostgreSQLParserSTART, PostgreSQLParserTRUNCATE, PostgreSQLParserUNLISTEN, PostgreSQLParserUPDATE, PostgreSQLParserVACUUM, PostgreSQLParserVALUES, PostgreSQLParserCALL, PostgreSQLParserIMPORT_P, PostgreSQLParserEND_P, PostgreSQLParserMetaCommand:
		p.EnterOuterAlt(localctx, 2)

	default:
		p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IAlter_usingContext is an interface to support dynamic dispatch.
type IAlter_usingContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	USING() antlr.TerminalNode
	A_expr() IA_exprContext

	// IsAlter_usingContext differentiates from other interfaces.
	IsAlter_usingContext()
}

type Alter_usingContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyAlter_usingContext() *Alter_usingContext {
	var p = new(Alter_usingContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_alter_using
	return p
}

func InitEmptyAlter_usingContext(p *Alter_usingContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_alter_using
}

func (*Alter_usingContext) IsAlter_usingContext() {}

func NewAlter_usingContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_usingContext {
	var p = new(Alter_usingContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_alter_using

	return p
}

func (s *Alter_usingContext) GetParser() antlr.Parser { return s.parser }

func (s *Alter_usingContext) USING() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserUSING, 0)
}

func (s *Alter_usingContext) A_expr() IA_exprContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IA_exprContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IA_exprContext)
}

func (s *Alter_usingContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Alter_usingContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Alter_usingContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterAlter_using(s)
	}
}

func (s *Alter_usingContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitAlter_using(s)
	}
}

func (s *Alter_usingContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitAlter_using(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Alter_using() (localctx IAlter_usingContext) {
	localctx = NewAlter_usingContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 112, PostgreSQLParserRULE_alter_using)
	p.SetState(2480)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetTokenStream().LA(1) {
	case PostgreSQLParserUSING:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(2477)
			p.Match(PostgreSQLParserUSING)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2478)
			p.A_expr()
		}

	case PostgreSQLParserEOF, PostgreSQLParserOPEN_PAREN, PostgreSQLParserCOMMA, PostgreSQLParserSEMI, PostgreSQLParserANALYSE, PostgreSQLParserANALYZE, PostgreSQLParserCREATE, PostgreSQLParserDO, PostgreSQLParserFETCH, PostgreSQLParserGRANT, PostgreSQLParserINTO, PostgreSQLParserSELECT, PostgreSQLParserTABLE, PostgreSQLParserWITH, PostgreSQLParserABORT_P, PostgreSQLParserALTER, PostgreSQLParserBEGIN_P, PostgreSQLParserCHECKPOINT, PostgreSQLParserCLOSE, PostgreSQLParserCLUSTER, PostgreSQLParserCOMMENT, PostgreSQLParserCOMMIT, PostgreSQLParserCOPY, PostgreSQLParserDEALLOCATE, PostgreSQLParserDECLARE, PostgreSQLParserDELETE_P, PostgreSQLParserDISCARD, PostgreSQLParserDROP, PostgreSQLParserEXECUTE, PostgreSQLParserEXPLAIN, PostgreSQLParserINSERT, PostgreSQLParserLISTEN, PostgreSQLParserLOAD, PostgreSQLParserLOCK_P, PostgreSQLParserMERGE, PostgreSQLParserMOVE, PostgreSQLParserNOTIFY, PostgreSQLParserPREPARE, PostgreSQLParserREASSIGN, PostgreSQLParserREFRESH, PostgreSQLParserREINDEX, PostgreSQLParserRELEASE, PostgreSQLParserRESET, PostgreSQLParserREVOKE, PostgreSQLParserROLLBACK, PostgreSQLParserSAVEPOINT, PostgreSQLParserSECURITY, PostgreSQLParserSET, PostgreSQLParserSHOW, PostgreSQLParserSTART, PostgreSQLParserTRUNCATE, PostgreSQLParserUNLISTEN, PostgreSQLParserUPDATE, PostgreSQLParserVACUUM, PostgreSQLParserVALUES, PostgreSQLParserCALL, PostgreSQLParserIMPORT_P, PostgreSQLParserEND_P, PostgreSQLParserMetaCommand:
		p.EnterOuterAlt(localctx, 2)

	default:
		p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IReplica_identityContext is an interface to support dynamic dispatch.
type IReplica_identityContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	NOTHING() antlr.TerminalNode
	FULL() antlr.TerminalNode
	DEFAULT() antlr.TerminalNode
	USING() antlr.TerminalNode
	INDEX() antlr.TerminalNode
	Name() INameContext

	// IsReplica_identityContext differentiates from other interfaces.
	IsReplica_identityContext()
}

type Replica_identityContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyReplica_identityContext() *Replica_identityContext {
	var p = new(Replica_identityContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_replica_identity
	return p
}

func InitEmptyReplica_identityContext(p *Replica_identityContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_replica_identity
}

func (*Replica_identityContext) IsReplica_identityContext() {}

func NewReplica_identityContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Replica_identityContext {
	var p = new(Replica_identityContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_replica_identity

	return p
}

func (s *Replica_identityContext) GetParser() antlr.Parser { return s.parser }

func (s *Replica_identityContext) NOTHING() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserNOTHING, 0)
}

func (s *Replica_identityContext) FULL() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserFULL, 0)
}

func (s *Replica_identityContext) DEFAULT() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserDEFAULT, 0)
}

func (s *Replica_identityContext) USING() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserUSING, 0)
}

func (s *Replica_identityContext) INDEX() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserINDEX, 0)
}

func (s *Replica_identityContext) Name() INameContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(INameContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(INameContext)
}

func (s *Replica_identityContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Replica_identityContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Replica_identityContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterReplica_identity(s)
	}
}

func (s *Replica_identityContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitReplica_identity(s)
	}
}

func (s *Replica_identityContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitReplica_identity(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Replica_identity() (localctx IReplica_identityContext) {
	localctx = NewReplica_identityContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 114, PostgreSQLParserRULE_replica_identity)
	p.SetState(2488)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetTokenStream().LA(1) {
	case PostgreSQLParserNOTHING:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(2482)
			p.Match(PostgreSQLParserNOTHING)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case PostgreSQLParserFULL:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(2483)
			p.Match(PostgreSQLParserFULL)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case PostgreSQLParserDEFAULT:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(2484)
			p.Match(PostgreSQLParserDEFAULT)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case PostgreSQLParserUSING:
		p.EnterOuterAlt(localctx, 4)
		{
			p.SetState(2485)
			p.Match(PostgreSQLParserUSING)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2486)
			p.Match(PostgreSQLParserINDEX)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2487)
			p.Name()
		}

	default:
		p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IReloptionsContext is an interface to support dynamic dispatch.
type IReloptionsContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	OPEN_PAREN() antlr.TerminalNode
	Reloption_list() IReloption_listContext
	CLOSE_PAREN() antlr.TerminalNode

	// IsReloptionsContext differentiates from other interfaces.
	IsReloptionsContext()
}

type ReloptionsContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyReloptionsContext() *ReloptionsContext {
	var p = new(ReloptionsContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_reloptions
	return p
}

func InitEmptyReloptionsContext(p *ReloptionsContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_reloptions
}

func (*ReloptionsContext) IsReloptionsContext() {}

func NewReloptionsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ReloptionsContext {
	var p = new(ReloptionsContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_reloptions

	return p
}

func (s *ReloptionsContext) GetParser() antlr.Parser { return s.parser }

func (s *ReloptionsContext) OPEN_PAREN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserOPEN_PAREN, 0)
}

func (s *ReloptionsContext) Reloption_list() IReloption_listContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IReloption_listContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IReloption_listContext)
}

func (s *ReloptionsContext) CLOSE_PAREN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCLOSE_PAREN, 0)
}

func (s *ReloptionsContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *ReloptionsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *ReloptionsContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterReloptions(s)
	}
}

func (s *ReloptionsContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitReloptions(s)
	}
}

func (s *ReloptionsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitReloptions(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Reloptions() (localctx IReloptionsContext) {
	localctx = NewReloptionsContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 116, PostgreSQLParserRULE_reloptions)
	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(2490)
		p.Match(PostgreSQLParserOPEN_PAREN)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(2491)
		p.Reloption_list()
	}
	{
		p.SetState(2492)
		p.Match(PostgreSQLParserCLOSE_PAREN)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IOpt_reloptionsContext is an interface to support dynamic dispatch.
type IOpt_reloptionsContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	WITH() antlr.TerminalNode
	Reloptions() IReloptionsContext

	// IsOpt_reloptionsContext differentiates from other interfaces.
	IsOpt_reloptionsContext()
}

type Opt_reloptionsContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyOpt_reloptionsContext() *Opt_reloptionsContext {
	var p = new(Opt_reloptionsContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opt_reloptions
	return p
}

func InitEmptyOpt_reloptionsContext(p *Opt_reloptionsContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opt_reloptions
}

func (*Opt_reloptionsContext) IsOpt_reloptionsContext() {}

func NewOpt_reloptionsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_reloptionsContext {
	var p = new(Opt_reloptionsContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_opt_reloptions

	return p
}

func (s *Opt_reloptionsContext) GetParser() antlr.Parser { return s.parser }

func (s *Opt_reloptionsContext) WITH() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserWITH, 0)
}

func (s *Opt_reloptionsContext) Reloptions() IReloptionsContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IReloptionsContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IReloptionsContext)
}

func (s *Opt_reloptionsContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Opt_reloptionsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Opt_reloptionsContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterOpt_reloptions(s)
	}
}

func (s *Opt_reloptionsContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitOpt_reloptions(s)
	}
}

func (s *Opt_reloptionsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitOpt_reloptions(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Opt_reloptions() (localctx IOpt_reloptionsContext) {
	localctx = NewOpt_reloptionsContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 118, PostgreSQLParserRULE_opt_reloptions)
	p.SetState(2497)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 55, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(2494)
			p.Match(PostgreSQLParserWITH)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2495)
			p.Reloptions()
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)

	case antlr.ATNInvalidAltNumber:
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IReloption_listContext is an interface to support dynamic dispatch.
type IReloption_listContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	AllReloption_elem() []IReloption_elemContext
	Reloption_elem(i int) IReloption_elemContext
	AllCOMMA() []antlr.TerminalNode
	COMMA(i int) antlr.TerminalNode

	// IsReloption_listContext differentiates from other interfaces.
	IsReloption_listContext()
}

type Reloption_listContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyReloption_listContext() *Reloption_listContext {
	var p = new(Reloption_listContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_reloption_list
	return p
}

func InitEmptyReloption_listContext(p *Reloption_listContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_reloption_list
}

func (*Reloption_listContext) IsReloption_listContext() {}

func NewReloption_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Reloption_listContext {
	var p = new(Reloption_listContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_reloption_list

	return p
}

func (s *Reloption_listContext) GetParser() antlr.Parser { return s.parser }

func (s *Reloption_listContext) AllReloption_elem() []IReloption_elemContext {
	children := s.GetChildren()
	len := 0
	for _, ctx := range children {
		if _, ok := ctx.(IReloption_elemContext); ok {
			len++
		}
	}

	tst := make([]IReloption_elemContext, len)
	i := 0
	for _, ctx := range children {
		if t, ok := ctx.(IReloption_elemContext); ok {
			tst[i] = t.(IReloption_elemContext)
			i++
		}
	}

	return tst
}

func (s *Reloption_listContext) Reloption_elem(i int) IReloption_elemContext {
	var t antlr.RuleContext
	j := 0
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IReloption_elemContext); ok {
			if j == i {
				t = ctx.(antlr.RuleContext)
				break
			}
			j++
		}
	}

	if t == nil {
		return nil
	}

	return t.(IReloption_elemContext)
}

func (s *Reloption_listContext) AllCOMMA() []antlr.TerminalNode {
	return s.GetTokens(PostgreSQLParserCOMMA)
}

func (s *Reloption_listContext) COMMA(i int) antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCOMMA, i)
}

func (s *Reloption_listContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Reloption_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Reloption_listContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterReloption_list(s)
	}
}

func (s *Reloption_listContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitReloption_list(s)
	}
}

func (s *Reloption_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitReloption_list(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Reloption_list() (localctx IReloption_listContext) {
	localctx = NewReloption_listContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 120, PostgreSQLParserRULE_reloption_list)
	var _la int

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(2499)
		p.Reloption_elem()
	}
	p.SetState(2504)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}
	_la = p.GetTokenStream().LA(1)

	for _la == PostgreSQLParserCOMMA {
		{
			p.SetState(2500)
			p.Match(PostgreSQLParserCOMMA)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2501)
			p.Reloption_elem()
		}

		p.SetState(2506)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}
		_la = p.GetTokenStream().LA(1)
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IReloption_elemContext is an interface to support dynamic dispatch.
type IReloption_elemContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	AllCollabel() []ICollabelContext
	Collabel(i int) ICollabelContext
	EQUAL() antlr.TerminalNode
	Def_arg() IDef_argContext
	DOT() antlr.TerminalNode

	// IsReloption_elemContext differentiates from other interfaces.
	IsReloption_elemContext()
}

type Reloption_elemContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyReloption_elemContext() *Reloption_elemContext {
	var p = new(Reloption_elemContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_reloption_elem
	return p
}

func InitEmptyReloption_elemContext(p *Reloption_elemContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_reloption_elem
}

func (*Reloption_elemContext) IsReloption_elemContext() {}

func NewReloption_elemContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Reloption_elemContext {
	var p = new(Reloption_elemContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_reloption_elem

	return p
}

func (s *Reloption_elemContext) GetParser() antlr.Parser { return s.parser }

func (s *Reloption_elemContext) AllCollabel() []ICollabelContext {
	children := s.GetChildren()
	len := 0
	for _, ctx := range children {
		if _, ok := ctx.(ICollabelContext); ok {
			len++
		}
	}

	tst := make([]ICollabelContext, len)
	i := 0
	for _, ctx := range children {
		if t, ok := ctx.(ICollabelContext); ok {
			tst[i] = t.(ICollabelContext)
			i++
		}
	}

	return tst
}

func (s *Reloption_elemContext) Collabel(i int) ICollabelContext {
	var t antlr.RuleContext
	j := 0
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ICollabelContext); ok {
			if j == i {
				t = ctx.(antlr.RuleContext)
				break
			}
			j++
		}
	}

	if t == nil {
		return nil
	}

	return t.(ICollabelContext)
}

func (s *Reloption_elemContext) EQUAL() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserEQUAL, 0)
}

func (s *Reloption_elemContext) Def_arg() IDef_argContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IDef_argContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IDef_argContext)
}

func (s *Reloption_elemContext) DOT() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserDOT, 0)
}

func (s *Reloption_elemContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Reloption_elemContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Reloption_elemContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterReloption_elem(s)
	}
}

func (s *Reloption_elemContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitReloption_elem(s)
	}
}

func (s *Reloption_elemContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitReloption_elem(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Reloption_elem() (localctx IReloption_elemContext) {
	localctx = NewReloption_elemContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 122, PostgreSQLParserRULE_reloption_elem)
	var _la int

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(2507)
		p.Collabel()
	}
	p.SetState(2516)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}
	switch p.GetTokenStream().LA(1) {
	case PostgreSQLParserEQUAL:
		{
			p.SetState(2508)
			p.Match(PostgreSQLParserEQUAL)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2509)
			p.Def_arg()
		}

	case PostgreSQLParserDOT:
		{
			p.SetState(2510)
			p.Match(PostgreSQLParserDOT)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2511)
			p.Collabel()
		}
		p.SetState(2514)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}
		_la = p.GetTokenStream().LA(1)

		if _la == PostgreSQLParserEQUAL {
			{
				p.SetState(2512)
				p.Match(PostgreSQLParserEQUAL)
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}
			{
				p.SetState(2513)
				p.Def_arg()
			}

		}

	case PostgreSQLParserCLOSE_PAREN, PostgreSQLParserCOMMA:

	default:
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IAlter_identity_column_option_listContext is an interface to support dynamic dispatch.
type IAlter_identity_column_option_listContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	AllAlter_identity_column_option() []IAlter_identity_column_optionContext
	Alter_identity_column_option(i int) IAlter_identity_column_optionContext

	// IsAlter_identity_column_option_listContext differentiates from other interfaces.
	IsAlter_identity_column_option_listContext()
}

type Alter_identity_column_option_listContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyAlter_identity_column_option_listContext() *Alter_identity_column_option_listContext {
	var p = new(Alter_identity_column_option_listContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_alter_identity_column_option_list
	return p
}

func InitEmptyAlter_identity_column_option_listContext(p *Alter_identity_column_option_listContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_alter_identity_column_option_list
}

func (*Alter_identity_column_option_listContext) IsAlter_identity_column_option_listContext() {}

func NewAlter_identity_column_option_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_identity_column_option_listContext {
	var p = new(Alter_identity_column_option_listContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_alter_identity_column_option_list

	return p
}

func (s *Alter_identity_column_option_listContext) GetParser() antlr.Parser { return s.parser }

func (s *Alter_identity_column_option_listContext) AllAlter_identity_column_option() []IAlter_identity_column_optionContext {
	children := s.GetChildren()
	len := 0
	for _, ctx := range children {
		if _, ok := ctx.(IAlter_identity_column_optionContext); ok {
			len++
		}
	}

	tst := make([]IAlter_identity_column_optionContext, len)
	i := 0
	for _, ctx := range children {
		if t, ok := ctx.(IAlter_identity_column_optionContext); ok {
			tst[i] = t.(IAlter_identity_column_optionContext)
			i++
		}
	}

	return tst
}

func (s *Alter_identity_column_option_listContext) Alter_identity_column_option(i int) IAlter_identity_column_optionContext {
	var t antlr.RuleContext
	j := 0
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IAlter_identity_column_optionContext); ok {
			if j == i {
				t = ctx.(antlr.RuleContext)
				break
			}
			j++
		}
	}

	if t == nil {
		return nil
	}

	return t.(IAlter_identity_column_optionContext)
}

func (s *Alter_identity_column_option_listContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Alter_identity_column_option_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Alter_identity_column_option_listContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterAlter_identity_column_option_list(s)
	}
}

func (s *Alter_identity_column_option_listContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitAlter_identity_column_option_list(s)
	}
}

func (s *Alter_identity_column_option_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitAlter_identity_column_option_list(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Alter_identity_column_option_list() (localctx IAlter_identity_column_option_listContext) {
	localctx = NewAlter_identity_column_option_listContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 124, PostgreSQLParserRULE_alter_identity_column_option_list)
	var _alt int

	p.EnterOuterAlt(localctx, 1)
	p.SetState(2519)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}
	_alt = 1
	for ok := true; ok; ok = _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
		switch _alt {
		case 1:
			{
				p.SetState(2518)
				p.Alter_identity_column_option()
			}

		default:
			p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
			goto errorExit
		}

		p.SetState(2521)
		p.GetErrorHandler().Sync(p)
		_alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 59, p.GetParserRuleContext())
		if p.HasError() {
			goto errorExit
		}
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IAlter_identity_column_optionContext is an interface to support dynamic dispatch.
type IAlter_identity_column_optionContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	RESTART() antlr.TerminalNode
	Opt_with() IOpt_withContext
	Numericonly() INumericonlyContext
	SET() antlr.TerminalNode
	Seqoptelem() ISeqoptelemContext
	GENERATED() antlr.TerminalNode
	Generated_when() IGenerated_whenContext

	// IsAlter_identity_column_optionContext differentiates from other interfaces.
	IsAlter_identity_column_optionContext()
}

type Alter_identity_column_optionContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyAlter_identity_column_optionContext() *Alter_identity_column_optionContext {
	var p = new(Alter_identity_column_optionContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_alter_identity_column_option
	return p
}

func InitEmptyAlter_identity_column_optionContext(p *Alter_identity_column_optionContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_alter_identity_column_option
}

func (*Alter_identity_column_optionContext) IsAlter_identity_column_optionContext() {}

func NewAlter_identity_column_optionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_identity_column_optionContext {
	var p = new(Alter_identity_column_optionContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_alter_identity_column_option

	return p
}

func (s *Alter_identity_column_optionContext) GetParser() antlr.Parser { return s.parser }

func (s *Alter_identity_column_optionContext) RESTART() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserRESTART, 0)
}

func (s *Alter_identity_column_optionContext) Opt_with() IOpt_withContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOpt_withContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOpt_withContext)
}

func (s *Alter_identity_column_optionContext) Numericonly() INumericonlyContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(INumericonlyContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(INumericonlyContext)
}

func (s *Alter_identity_column_optionContext) SET() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserSET, 0)
}

func (s *Alter_identity_column_optionContext) Seqoptelem() ISeqoptelemContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ISeqoptelemContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ISeqoptelemContext)
}

func (s *Alter_identity_column_optionContext) GENERATED() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserGENERATED, 0)
}

func (s *Alter_identity_column_optionContext) Generated_when() IGenerated_whenContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IGenerated_whenContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IGenerated_whenContext)
}

func (s *Alter_identity_column_optionContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Alter_identity_column_optionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Alter_identity_column_optionContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterAlter_identity_column_option(s)
	}
}

func (s *Alter_identity_column_optionContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitAlter_identity_column_option(s)
	}
}

func (s *Alter_identity_column_optionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitAlter_identity_column_option(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Alter_identity_column_option() (localctx IAlter_identity_column_optionContext) {
	localctx = NewAlter_identity_column_optionContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 126, PostgreSQLParserRULE_alter_identity_column_option)
	p.SetState(2535)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetTokenStream().LA(1) {
	case PostgreSQLParserRESTART:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(2523)
			p.Match(PostgreSQLParserRESTART)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		p.SetState(2527)
		p.GetErrorHandler().Sync(p)

		if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 60, p.GetParserRuleContext()) == 1 {
			{
				p.SetState(2524)
				p.Opt_with()
			}
			{
				p.SetState(2525)
				p.Numericonly()
			}

		} else if p.HasError() { // JIM
			goto errorExit
		}

	case PostgreSQLParserSET:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(2529)
			p.Match(PostgreSQLParserSET)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		p.SetState(2533)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}

		switch p.GetTokenStream().LA(1) {
		case PostgreSQLParserAS, PostgreSQLParserCACHE, PostgreSQLParserCYCLE, PostgreSQLParserINCREMENT, PostgreSQLParserMAXVALUE, PostgreSQLParserMINVALUE, PostgreSQLParserNO, PostgreSQLParserOWNED, PostgreSQLParserRESTART, PostgreSQLParserSEQUENCE, PostgreSQLParserSTART:
			{
				p.SetState(2530)
				p.Seqoptelem()
			}

		case PostgreSQLParserGENERATED:
			{
				p.SetState(2531)
				p.Match(PostgreSQLParserGENERATED)
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}
			{
				p.SetState(2532)
				p.Generated_when()
			}

		default:
			p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
			goto errorExit
		}

	default:
		p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IPartitionboundspecContext is an interface to support dynamic dispatch.
type IPartitionboundspecContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	FOR() antlr.TerminalNode
	VALUES() antlr.TerminalNode
	WITH() antlr.TerminalNode
	AllOPEN_PAREN() []antlr.TerminalNode
	OPEN_PAREN(i int) antlr.TerminalNode
	Hash_partbound() IHash_partboundContext
	AllCLOSE_PAREN() []antlr.TerminalNode
	CLOSE_PAREN(i int) antlr.TerminalNode
	IN_P() antlr.TerminalNode
	AllExpr_list() []IExpr_listContext
	Expr_list(i int) IExpr_listContext
	FROM() antlr.TerminalNode
	TO() antlr.TerminalNode
	DEFAULT() antlr.TerminalNode

	// IsPartitionboundspecContext differentiates from other interfaces.
	IsPartitionboundspecContext()
}

type PartitionboundspecContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyPartitionboundspecContext() *PartitionboundspecContext {
	var p = new(PartitionboundspecContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_partitionboundspec
	return p
}

func InitEmptyPartitionboundspecContext(p *PartitionboundspecContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_partitionboundspec
}

func (*PartitionboundspecContext) IsPartitionboundspecContext() {}

func NewPartitionboundspecContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *PartitionboundspecContext {
	var p = new(PartitionboundspecContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_partitionboundspec

	return p
}

func (s *PartitionboundspecContext) GetParser() antlr.Parser { return s.parser }

func (s *PartitionboundspecContext) FOR() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserFOR, 0)
}

func (s *PartitionboundspecContext) VALUES() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserVALUES, 0)
}

func (s *PartitionboundspecContext) WITH() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserWITH, 0)
}

func (s *PartitionboundspecContext) AllOPEN_PAREN() []antlr.TerminalNode {
	return s.GetTokens(PostgreSQLParserOPEN_PAREN)
}

func (s *PartitionboundspecContext) OPEN_PAREN(i int) antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserOPEN_PAREN, i)
}

func (s *PartitionboundspecContext) Hash_partbound() IHash_partboundContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IHash_partboundContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IHash_partboundContext)
}

func (s *PartitionboundspecContext) AllCLOSE_PAREN() []antlr.TerminalNode {
	return s.GetTokens(PostgreSQLParserCLOSE_PAREN)
}

func (s *PartitionboundspecContext) CLOSE_PAREN(i int) antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCLOSE_PAREN, i)
}

func (s *PartitionboundspecContext) IN_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserIN_P, 0)
}

func (s *PartitionboundspecContext) AllExpr_list() []IExpr_listContext {
	children := s.GetChildren()
	len := 0
	for _, ctx := range children {
		if _, ok := ctx.(IExpr_listContext); ok {
			len++
		}
	}

	tst := make([]IExpr_listContext, len)
	i := 0
	for _, ctx := range children {
		if t, ok := ctx.(IExpr_listContext); ok {
			tst[i] = t.(IExpr_listContext)
			i++
		}
	}

	return tst
}

func (s *PartitionboundspecContext) Expr_list(i int) IExpr_listContext {
	var t antlr.RuleContext
	j := 0
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IExpr_listContext); ok {
			if j == i {
				t = ctx.(antlr.RuleContext)
				break
			}
			j++
		}
	}

	if t == nil {
		return nil
	}

	return t.(IExpr_listContext)
}

func (s *PartitionboundspecContext) FROM() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserFROM, 0)
}

func (s *PartitionboundspecContext) TO() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserTO, 0)
}

func (s *PartitionboundspecContext) DEFAULT() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserDEFAULT, 0)
}

func (s *PartitionboundspecContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *PartitionboundspecContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *PartitionboundspecContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterPartitionboundspec(s)
	}
}

func (s *PartitionboundspecContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitPartitionboundspec(s)
	}
}

func (s *PartitionboundspecContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitPartitionboundspec(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Partitionboundspec() (localctx IPartitionboundspecContext) {
	localctx = NewPartitionboundspecContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 128, PostgreSQLParserRULE_partitionboundspec)
	p.SetState(2563)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 63, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(2537)
			p.Match(PostgreSQLParserFOR)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2538)
			p.Match(PostgreSQLParserVALUES)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2539)
			p.Match(PostgreSQLParserWITH)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2540)
			p.Match(PostgreSQLParserOPEN_PAREN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2541)
			p.Hash_partbound()
		}
		{
			p.SetState(2542)
			p.Match(PostgreSQLParserCLOSE_PAREN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(2544)
			p.Match(PostgreSQLParserFOR)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2545)
			p.Match(PostgreSQLParserVALUES)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2546)
			p.Match(PostgreSQLParserIN_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2547)
			p.Match(PostgreSQLParserOPEN_PAREN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2548)
			p.Expr_list()
		}
		{
			p.SetState(2549)
			p.Match(PostgreSQLParserCLOSE_PAREN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 3:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(2551)
			p.Match(PostgreSQLParserFOR)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2552)
			p.Match(PostgreSQLParserVALUES)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2553)
			p.Match(PostgreSQLParserFROM)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2554)
			p.Match(PostgreSQLParserOPEN_PAREN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2555)
			p.Expr_list()
		}
		{
			p.SetState(2556)
			p.Match(PostgreSQLParserCLOSE_PAREN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2557)
			p.Match(PostgreSQLParserTO)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2558)
			p.Match(PostgreSQLParserOPEN_PAREN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2559)
			p.Expr_list()
		}
		{
			p.SetState(2560)
			p.Match(PostgreSQLParserCLOSE_PAREN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 4:
		p.EnterOuterAlt(localctx, 4)
		{
			p.SetState(2562)
			p.Match(PostgreSQLParserDEFAULT)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case antlr.ATNInvalidAltNumber:
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IHash_partbound_elemContext is an interface to support dynamic dispatch.
type IHash_partbound_elemContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Nonreservedword() INonreservedwordContext
	Iconst() IIconstContext

	// IsHash_partbound_elemContext differentiates from other interfaces.
	IsHash_partbound_elemContext()
}

type Hash_partbound_elemContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyHash_partbound_elemContext() *Hash_partbound_elemContext {
	var p = new(Hash_partbound_elemContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_hash_partbound_elem
	return p
}

func InitEmptyHash_partbound_elemContext(p *Hash_partbound_elemContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_hash_partbound_elem
}

func (*Hash_partbound_elemContext) IsHash_partbound_elemContext() {}

func NewHash_partbound_elemContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Hash_partbound_elemContext {
	var p = new(Hash_partbound_elemContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_hash_partbound_elem

	return p
}

func (s *Hash_partbound_elemContext) GetParser() antlr.Parser { return s.parser }

func (s *Hash_partbound_elemContext) Nonreservedword() INonreservedwordContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(INonreservedwordContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(INonreservedwordContext)
}

func (s *Hash_partbound_elemContext) Iconst() IIconstContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IIconstContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IIconstContext)
}

func (s *Hash_partbound_elemContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Hash_partbound_elemContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Hash_partbound_elemContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterHash_partbound_elem(s)
	}
}

func (s *Hash_partbound_elemContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitHash_partbound_elem(s)
	}
}

func (s *Hash_partbound_elemContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitHash_partbound_elem(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Hash_partbound_elem() (localctx IHash_partbound_elemContext) {
	localctx = NewHash_partbound_elemContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 130, PostgreSQLParserRULE_hash_partbound_elem)
	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(2565)
		p.Nonreservedword()
	}
	{
		p.SetState(2566)
		p.Iconst()
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IHash_partboundContext is an interface to support dynamic dispatch.
type IHash_partboundContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	AllHash_partbound_elem() []IHash_partbound_elemContext
	Hash_partbound_elem(i int) IHash_partbound_elemContext
	AllCOMMA() []antlr.TerminalNode
	COMMA(i int) antlr.TerminalNode

	// IsHash_partboundContext differentiates from other interfaces.
	IsHash_partboundContext()
}

type Hash_partboundContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyHash_partboundContext() *Hash_partboundContext {
	var p = new(Hash_partboundContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_hash_partbound
	return p
}

func InitEmptyHash_partboundContext(p *Hash_partboundContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_hash_partbound
}

func (*Hash_partboundContext) IsHash_partboundContext() {}

func NewHash_partboundContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Hash_partboundContext {
	var p = new(Hash_partboundContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_hash_partbound

	return p
}

func (s *Hash_partboundContext) GetParser() antlr.Parser { return s.parser }

func (s *Hash_partboundContext) AllHash_partbound_elem() []IHash_partbound_elemContext {
	children := s.GetChildren()
	len := 0
	for _, ctx := range children {
		if _, ok := ctx.(IHash_partbound_elemContext); ok {
			len++
		}
	}

	tst := make([]IHash_partbound_elemContext, len)
	i := 0
	for _, ctx := range children {
		if t, ok := ctx.(IHash_partbound_elemContext); ok {
			tst[i] = t.(IHash_partbound_elemContext)
			i++
		}
	}

	return tst
}

func (s *Hash_partboundContext) Hash_partbound_elem(i int) IHash_partbound_elemContext {
	var t antlr.RuleContext
	j := 0
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IHash_partbound_elemContext); ok {
			if j == i {
				t = ctx.(antlr.RuleContext)
				break
			}
			j++
		}
	}

	if t == nil {
		return nil
	}

	return t.(IHash_partbound_elemContext)
}

func (s *Hash_partboundContext) AllCOMMA() []antlr.TerminalNode {
	return s.GetTokens(PostgreSQLParserCOMMA)
}

func (s *Hash_partboundContext) COMMA(i int) antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCOMMA, i)
}

func (s *Hash_partboundContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Hash_partboundContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Hash_partboundContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterHash_partbound(s)
	}
}

func (s *Hash_partboundContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitHash_partbound(s)
	}
}

func (s *Hash_partboundContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitHash_partbound(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Hash_partbound() (localctx IHash_partboundContext) {
	localctx = NewHash_partboundContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 132, PostgreSQLParserRULE_hash_partbound)
	var _la int

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(2568)
		p.Hash_partbound_elem()
	}
	p.SetState(2573)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}
	_la = p.GetTokenStream().LA(1)

	for _la == PostgreSQLParserCOMMA {
		{
			p.SetState(2569)
			p.Match(PostgreSQLParserCOMMA)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2570)
			p.Hash_partbound_elem()
		}

		p.SetState(2575)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}
		_la = p.GetTokenStream().LA(1)
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IAltercompositetypestmtContext is an interface to support dynamic dispatch.
type IAltercompositetypestmtContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	ALTER() antlr.TerminalNode
	TYPE_P() antlr.TerminalNode
	Any_name() IAny_nameContext
	Alter_type_cmds() IAlter_type_cmdsContext

	// IsAltercompositetypestmtContext differentiates from other interfaces.
	IsAltercompositetypestmtContext()
}

type AltercompositetypestmtContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyAltercompositetypestmtContext() *AltercompositetypestmtContext {
	var p = new(AltercompositetypestmtContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_altercompositetypestmt
	return p
}

func InitEmptyAltercompositetypestmtContext(p *AltercompositetypestmtContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_altercompositetypestmt
}

func (*AltercompositetypestmtContext) IsAltercompositetypestmtContext() {}

func NewAltercompositetypestmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AltercompositetypestmtContext {
	var p = new(AltercompositetypestmtContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_altercompositetypestmt

	return p
}

func (s *AltercompositetypestmtContext) GetParser() antlr.Parser { return s.parser }

func (s *AltercompositetypestmtContext) ALTER() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserALTER, 0)
}

func (s *AltercompositetypestmtContext) TYPE_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserTYPE_P, 0)
}

func (s *AltercompositetypestmtContext) Any_name() IAny_nameContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IAny_nameContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IAny_nameContext)
}

func (s *AltercompositetypestmtContext) Alter_type_cmds() IAlter_type_cmdsContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IAlter_type_cmdsContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IAlter_type_cmdsContext)
}

func (s *AltercompositetypestmtContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *AltercompositetypestmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *AltercompositetypestmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterAltercompositetypestmt(s)
	}
}

func (s *AltercompositetypestmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitAltercompositetypestmt(s)
	}
}

func (s *AltercompositetypestmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitAltercompositetypestmt(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Altercompositetypestmt() (localctx IAltercompositetypestmtContext) {
	localctx = NewAltercompositetypestmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 134, PostgreSQLParserRULE_altercompositetypestmt)
	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(2576)
		p.Match(PostgreSQLParserALTER)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(2577)
		p.Match(PostgreSQLParserTYPE_P)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(2578)
		p.Any_name()
	}
	{
		p.SetState(2579)
		p.Alter_type_cmds()
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IAlter_type_cmdsContext is an interface to support dynamic dispatch.
type IAlter_type_cmdsContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	AllAlter_type_cmd() []IAlter_type_cmdContext
	Alter_type_cmd(i int) IAlter_type_cmdContext
	AllCOMMA() []antlr.TerminalNode
	COMMA(i int) antlr.TerminalNode

	// IsAlter_type_cmdsContext differentiates from other interfaces.
	IsAlter_type_cmdsContext()
}

type Alter_type_cmdsContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyAlter_type_cmdsContext() *Alter_type_cmdsContext {
	var p = new(Alter_type_cmdsContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_alter_type_cmds
	return p
}

func InitEmptyAlter_type_cmdsContext(p *Alter_type_cmdsContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_alter_type_cmds
}

func (*Alter_type_cmdsContext) IsAlter_type_cmdsContext() {}

func NewAlter_type_cmdsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_type_cmdsContext {
	var p = new(Alter_type_cmdsContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_alter_type_cmds

	return p
}

func (s *Alter_type_cmdsContext) GetParser() antlr.Parser { return s.parser }

func (s *Alter_type_cmdsContext) AllAlter_type_cmd() []IAlter_type_cmdContext {
	children := s.GetChildren()
	len := 0
	for _, ctx := range children {
		if _, ok := ctx.(IAlter_type_cmdContext); ok {
			len++
		}
	}

	tst := make([]IAlter_type_cmdContext, len)
	i := 0
	for _, ctx := range children {
		if t, ok := ctx.(IAlter_type_cmdContext); ok {
			tst[i] = t.(IAlter_type_cmdContext)
			i++
		}
	}

	return tst
}

func (s *Alter_type_cmdsContext) Alter_type_cmd(i int) IAlter_type_cmdContext {
	var t antlr.RuleContext
	j := 0
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IAlter_type_cmdContext); ok {
			if j == i {
				t = ctx.(antlr.RuleContext)
				break
			}
			j++
		}
	}

	if t == nil {
		return nil
	}

	return t.(IAlter_type_cmdContext)
}

func (s *Alter_type_cmdsContext) AllCOMMA() []antlr.TerminalNode {
	return s.GetTokens(PostgreSQLParserCOMMA)
}

func (s *Alter_type_cmdsContext) COMMA(i int) antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCOMMA, i)
}

func (s *Alter_type_cmdsContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Alter_type_cmdsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Alter_type_cmdsContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterAlter_type_cmds(s)
	}
}

func (s *Alter_type_cmdsContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitAlter_type_cmds(s)
	}
}

func (s *Alter_type_cmdsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitAlter_type_cmds(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Alter_type_cmds() (localctx IAlter_type_cmdsContext) {
	localctx = NewAlter_type_cmdsContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 136, PostgreSQLParserRULE_alter_type_cmds)
	var _la int

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(2581)
		p.Alter_type_cmd()
	}
	p.SetState(2586)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}
	_la = p.GetTokenStream().LA(1)

	for _la == PostgreSQLParserCOMMA {
		{
			p.SetState(2582)
			p.Match(PostgreSQLParserCOMMA)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2583)
			p.Alter_type_cmd()
		}

		p.SetState(2588)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}
		_la = p.GetTokenStream().LA(1)
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IAlter_type_cmdContext is an interface to support dynamic dispatch.
type IAlter_type_cmdContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	ADD_P() antlr.TerminalNode
	ATTRIBUTE() antlr.TerminalNode
	Tablefuncelement() ITablefuncelementContext
	Opt_drop_behavior() IOpt_drop_behaviorContext
	DROP() antlr.TerminalNode
	Colid() IColidContext
	IF_P() antlr.TerminalNode
	EXISTS() antlr.TerminalNode
	ALTER() antlr.TerminalNode
	Opt_set_data() IOpt_set_dataContext
	TYPE_P() antlr.TerminalNode
	Typename() ITypenameContext
	Opt_collate_clause() IOpt_collate_clauseContext

	// IsAlter_type_cmdContext differentiates from other interfaces.
	IsAlter_type_cmdContext()
}

type Alter_type_cmdContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyAlter_type_cmdContext() *Alter_type_cmdContext {
	var p = new(Alter_type_cmdContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_alter_type_cmd
	return p
}

func InitEmptyAlter_type_cmdContext(p *Alter_type_cmdContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_alter_type_cmd
}

func (*Alter_type_cmdContext) IsAlter_type_cmdContext() {}

func NewAlter_type_cmdContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_type_cmdContext {
	var p = new(Alter_type_cmdContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_alter_type_cmd

	return p
}

func (s *Alter_type_cmdContext) GetParser() antlr.Parser { return s.parser }

func (s *Alter_type_cmdContext) ADD_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserADD_P, 0)
}

func (s *Alter_type_cmdContext) ATTRIBUTE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserATTRIBUTE, 0)
}

func (s *Alter_type_cmdContext) Tablefuncelement() ITablefuncelementContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ITablefuncelementContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ITablefuncelementContext)
}

func (s *Alter_type_cmdContext) Opt_drop_behavior() IOpt_drop_behaviorContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOpt_drop_behaviorContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOpt_drop_behaviorContext)
}

func (s *Alter_type_cmdContext) DROP() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserDROP, 0)
}

func (s *Alter_type_cmdContext) Colid() IColidContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IColidContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IColidContext)
}

func (s *Alter_type_cmdContext) IF_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserIF_P, 0)
}

func (s *Alter_type_cmdContext) EXISTS() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserEXISTS, 0)
}

func (s *Alter_type_cmdContext) ALTER() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserALTER, 0)
}

func (s *Alter_type_cmdContext) Opt_set_data() IOpt_set_dataContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOpt_set_dataContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOpt_set_dataContext)
}

func (s *Alter_type_cmdContext) TYPE_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserTYPE_P, 0)
}

func (s *Alter_type_cmdContext) Typename() ITypenameContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ITypenameContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ITypenameContext)
}

func (s *Alter_type_cmdContext) Opt_collate_clause() IOpt_collate_clauseContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOpt_collate_clauseContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOpt_collate_clauseContext)
}

func (s *Alter_type_cmdContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Alter_type_cmdContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Alter_type_cmdContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterAlter_type_cmd(s)
	}
}

func (s *Alter_type_cmdContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitAlter_type_cmd(s)
	}
}

func (s *Alter_type_cmdContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitAlter_type_cmd(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Alter_type_cmd() (localctx IAlter_type_cmdContext) {
	localctx = NewAlter_type_cmdContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 138, PostgreSQLParserRULE_alter_type_cmd)
	p.SetState(2612)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetTokenStream().LA(1) {
	case PostgreSQLParserADD_P:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(2589)
			p.Match(PostgreSQLParserADD_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2590)
			p.Match(PostgreSQLParserATTRIBUTE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2591)
			p.Tablefuncelement()
		}
		{
			p.SetState(2592)
			p.Opt_drop_behavior()
		}

	case PostgreSQLParserDROP:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(2594)
			p.Match(PostgreSQLParserDROP)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2595)
			p.Match(PostgreSQLParserATTRIBUTE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		p.SetState(2598)
		p.GetErrorHandler().Sync(p)

		if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 66, p.GetParserRuleContext()) == 1 {
			{
				p.SetState(2596)
				p.Match(PostgreSQLParserIF_P)
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}
			{
				p.SetState(2597)
				p.Match(PostgreSQLParserEXISTS)
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}

		} else if p.HasError() { // JIM
			goto errorExit
		}
		{
			p.SetState(2600)
			p.Colid()
		}
		{
			p.SetState(2601)
			p.Opt_drop_behavior()
		}

	case PostgreSQLParserALTER:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(2603)
			p.Match(PostgreSQLParserALTER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2604)
			p.Match(PostgreSQLParserATTRIBUTE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2605)
			p.Colid()
		}
		{
			p.SetState(2606)
			p.Opt_set_data()
		}
		{
			p.SetState(2607)
			p.Match(PostgreSQLParserTYPE_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2608)
			p.Typename()
		}
		{
			p.SetState(2609)
			p.Opt_collate_clause()
		}
		{
			p.SetState(2610)
			p.Opt_drop_behavior()
		}

	default:
		p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// ICloseportalstmtContext is an interface to support dynamic dispatch.
type ICloseportalstmtContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	CLOSE() antlr.TerminalNode
	Cursor_name() ICursor_nameContext
	ALL() antlr.TerminalNode

	// IsCloseportalstmtContext differentiates from other interfaces.
	IsCloseportalstmtContext()
}

type CloseportalstmtContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyCloseportalstmtContext() *CloseportalstmtContext {
	var p = new(CloseportalstmtContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_closeportalstmt
	return p
}

func InitEmptyCloseportalstmtContext(p *CloseportalstmtContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_closeportalstmt
}

func (*CloseportalstmtContext) IsCloseportalstmtContext() {}

func NewCloseportalstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CloseportalstmtContext {
	var p = new(CloseportalstmtContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_closeportalstmt

	return p
}

func (s *CloseportalstmtContext) GetParser() antlr.Parser { return s.parser }

func (s *CloseportalstmtContext) CLOSE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCLOSE, 0)
}

func (s *CloseportalstmtContext) Cursor_name() ICursor_nameContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ICursor_nameContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ICursor_nameContext)
}

func (s *CloseportalstmtContext) ALL() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserALL, 0)
}

func (s *CloseportalstmtContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *CloseportalstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *CloseportalstmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterCloseportalstmt(s)
	}
}

func (s *CloseportalstmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitCloseportalstmt(s)
	}
}

func (s *CloseportalstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitCloseportalstmt(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Closeportalstmt() (localctx ICloseportalstmtContext) {
	localctx = NewCloseportalstmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 140, PostgreSQLParserRULE_closeportalstmt)
	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(2614)
		p.Match(PostgreSQLParserCLOSE)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	p.SetState(2617)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetTokenStream().LA(1) {
	case PostgreSQLParserAND, PostgreSQLParserARRAY, PostgreSQLParserCOLLATE, PostgreSQLParserCOLUMN, PostgreSQLParserCONSTRAINT, PostgreSQLParserDEFAULT, PostgreSQLParserDO, PostgreSQLParserFETCH, PostgreSQLParserTABLE, PostgreSQLParserIS, PostgreSQLParserLEFT, PostgreSQLParserOUTER_P, PostgreSQLParserOVER, PostgreSQLParserRIGHT, PostgreSQLParserABORT_P, PostgreSQLParserABSOLUTE_P, PostgreSQLParserACCESS, PostgreSQLParserACTION, PostgreSQLParserADD_P, PostgreSQLParserADMIN, PostgreSQLParserAFTER, PostgreSQLParserAGGREGATE, PostgreSQLParserALSO, PostgreSQLParserALTER, PostgreSQLParserALWAYS, PostgreSQLParserASSERTION, PostgreSQLParserASSIGNMENT, PostgreSQLParserAT, PostgreSQLParserATTRIBUTE, PostgreSQLParserBACKWARD, PostgreSQLParserBEFORE, PostgreSQLParserBEGIN_P, PostgreSQLParserBY, PostgreSQLParserCACHE, PostgreSQLParserCALLED, PostgreSQLParserCASCADE, PostgreSQLParserCASCADED, PostgreSQLParserCATALOG, PostgreSQLParserCHAIN, PostgreSQLParserCHARACTERISTICS, PostgreSQLParserCHECKPOINT, PostgreSQLParserCLASS, PostgreSQLParserCLOSE, PostgreSQLParserCLUSTER, PostgreSQLParserCOMMENT, PostgreSQLParserCOMMENTS, PostgreSQLParserCOMMIT, PostgreSQLParserCOMMITTED, PostgreSQLParserCONFIGURATION, PostgreSQLParserCONNECTION, PostgreSQLParserCONSTRAINTS, PostgreSQLParserCONTENT_P, PostgreSQLParserCONTINUE_P, PostgreSQLParserCONVERSION_P, PostgreSQLParserCOPY, PostgreSQLParserCOST, PostgreSQLParserCSV, PostgreSQLParserCURSOR, PostgreSQLParserCYCLE, PostgreSQLParserDATA_P, PostgreSQLParserDATABASE, PostgreSQLParserDAY_P, PostgreSQLParserDEALLOCATE, PostgreSQLParserDECLARE, PostgreSQLParserDEFAULTS, PostgreSQLParserDEFERRED, PostgreSQLParserDEFINER, PostgreSQLParserDELETE_P, PostgreSQLParserDELIMITER, PostgreSQLParserDELIMITERS, PostgreSQLParserDICTIONARY, PostgreSQLParserDISABLE_P, PostgreSQLParserDISCARD, PostgreSQLParserDOCUMENT_P, PostgreSQLParserDOMAIN_P, PostgreSQLParserDOUBLE_P, PostgreSQLParserDROP, PostgreSQLParserEACH, PostgreSQLParserENABLE_P, PostgreSQLParserENCODING, PostgreSQLParserENCRYPTED, PostgreSQLParserENUM_P, PostgreSQLParserESCAPE, PostgreSQLParserEVENT, PostgreSQLParserEXCLUDE, PostgreSQLParserEXCLUDING, PostgreSQLParserEXCLUSIVE, PostgreSQLParserEXECUTE, PostgreSQLParserEXPLAIN, PostgreSQLParserEXTENSION, PostgreSQLParserEXTERNAL, PostgreSQLParserFAMILY, PostgreSQLParserFIRST_P, PostgreSQLParserFOLLOWING, PostgreSQLParserFORCE, PostgreSQLParserFORWARD, PostgreSQLParserFUNCTION, PostgreSQLParserFUNCTIONS, PostgreSQLParserGLOBAL, PostgreSQLParserGRANTED, PostgreSQLParserHANDLER, PostgreSQLParserHEADER_P, PostgreSQLParserHOLD, PostgreSQLParserHOUR_P, PostgreSQLParserIDENTITY_P, PostgreSQLParserIF_P, PostgreSQLParserIMMEDIATE, PostgreSQLParserIMMUTABLE, PostgreSQLParserIMPLICIT_P, PostgreSQLParserINCLUDING, PostgreSQLParserINCREMENT, PostgreSQLParserINDEX, PostgreSQLParserINDEXES, PostgreSQLParserINHERIT, PostgreSQLParserINHERITS, PostgreSQLParserINLINE_P, PostgreSQLParserINSENSITIVE, PostgreSQLParserINSERT, PostgreSQLParserINSTEAD, PostgreSQLParserINVOKER, PostgreSQLParserISOLATION, PostgreSQLParserKEY, PostgreSQLParserLABEL, PostgreSQLParserLANGUAGE, PostgreSQLParserLARGE_P, PostgreSQLParserLAST_P, PostgreSQLParserLEAKPROOF, PostgreSQLParserLEVEL, PostgreSQLParserLISTEN, PostgreSQLParserLOAD, PostgreSQLParserLOCAL, PostgreSQLParserLOCATION, PostgreSQLParserLOCK_P, PostgreSQLParserMAPPING, PostgreSQLParserMATCH, PostgreSQLParserMATERIALIZED, PostgreSQLParserMAXVALUE, PostgreSQLParserMINUTE_P, PostgreSQLParserMINVALUE, PostgreSQLParserMODE, PostgreSQLParserMONTH_P, PostgreSQLParserMOVE, PostgreSQLParserNAME_P, PostgreSQLParserNAMES, PostgreSQLParserNEXT, PostgreSQLParserNO, PostgreSQLParserNOTHING, PostgreSQLParserNOTIFY, PostgreSQLParserNOWAIT, PostgreSQLParserNULLS_P, PostgreSQLParserOBJECT_P, PostgreSQLParserOF, PostgreSQLParserOFF, PostgreSQLParserOIDS, PostgreSQLParserOPERATOR, PostgreSQLParserOPTION, PostgreSQLParserOPTIONS, PostgreSQLParserOWNED, PostgreSQLParserOWNER, PostgreSQLParserPARSER, PostgreSQLParserPARTIAL, PostgreSQLParserPARTITION, PostgreSQLParserPASSING, PostgreSQLParserPASSWORD, PostgreSQLParserPLANS, PostgreSQLParserPRECEDING, PostgreSQLParserPREPARE, PostgreSQLParserPREPARED, PostgreSQLParserPRESERVE, PostgreSQLParserPRIOR, PostgreSQLParserPRIVILEGES, PostgreSQLParserPROCEDURAL, PostgreSQLParserPROCEDURE, PostgreSQLParserPROGRAM, PostgreSQLParserQUOTE, PostgreSQLParserRANGE, PostgreSQLParserREAD, PostgreSQLParserREASSIGN, PostgreSQLParserRECHECK, PostgreSQLParserRECURSIVE, PostgreSQLParserREF, PostgreSQLParserREFRESH, PostgreSQLParserREINDEX, PostgreSQLParserRELATIVE_P, PostgreSQLParserRELEASE, PostgreSQLParserRENAME, PostgreSQLParserREPEATABLE, PostgreSQLParserREPLACE, PostgreSQLParserREPLICA, PostgreSQLParserRESET, PostgreSQLParserRESTART, PostgreSQLParserRESTRICT, PostgreSQLParserRETURNS, PostgreSQLParserREVOKE, PostgreSQLParserROLE, PostgreSQLParserROLLBACK, PostgreSQLParserROWS, PostgreSQLParserRULE, PostgreSQLParserSAVEPOINT, PostgreSQLParserSCHEMA, PostgreSQLParserSCROLL, PostgreSQLParserSEARCH, PostgreSQLParserSECOND_P, PostgreSQLParserSECURITY, PostgreSQLParserSEQUENCE, PostgreSQLParserSEQUENCES, PostgreSQLParserSERIALIZABLE, PostgreSQLParserSERVER, PostgreSQLParserSESSION, PostgreSQLParserSET, PostgreSQLParserSHARE, PostgreSQLParserSHOW, PostgreSQLParserSIMPLE, PostgreSQLParserSNAPSHOT, PostgreSQLParserSTABLE, PostgreSQLParserSTANDALONE_P, PostgreSQLParserSTART, PostgreSQLParserSTATEMENT, PostgreSQLParserSTATISTICS, PostgreSQLParserSTDIN, PostgreSQLParserSTDOUT, PostgreSQLParserSTORAGE, PostgreSQLParserSTRICT_P, PostgreSQLParserSTRIP_P, PostgreSQLParserSYSID, PostgreSQLParserSYSTEM_P, PostgreSQLParserTABLES, PostgreSQLParserTABLESPACE, PostgreSQLParserTEMP, PostgreSQLParserTEMPLATE, PostgreSQLParserTEMPORARY, PostgreSQLParserTEXT_P, PostgreSQLParserTRANSACTION, PostgreSQLParserTRIGGER, PostgreSQLParserTRUNCATE, PostgreSQLParserTRUSTED, PostgreSQLParserTYPE_P, PostgreSQLParserTYPES_P, PostgreSQLParserUNBOUNDED, PostgreSQLParserUNCOMMITTED, PostgreSQLParserUNENCRYPTED, PostgreSQLParserUNKNOWN, PostgreSQLParserUNLISTEN, PostgreSQLParserUNLOGGED, PostgreSQLParserUNTIL, PostgreSQLParserUPDATE, PostgreSQLParserVACUUM, PostgreSQLParserVALID, PostgreSQLParserVALIDATE, PostgreSQLParserVALIDATOR, PostgreSQLParserVARYING, PostgreSQLParserVERSION_P, PostgreSQLParserVIEW, PostgreSQLParserVOLATILE, PostgreSQLParserWHITESPACE_P, PostgreSQLParserWITHOUT, PostgreSQLParserWORK, PostgreSQLParserWRAPPER, PostgreSQLParserWRITE, PostgreSQLParserXML_P, PostgreSQLParserYEAR_P, PostgreSQLParserYES_P, PostgreSQLParserZONE, PostgreSQLParserBETWEEN, PostgreSQLParserBIGINT, PostgreSQLParserBIT, PostgreSQLParserBOOLEAN_P, PostgreSQLParserCHAR_P, PostgreSQLParserCHARACTER, PostgreSQLParserCOALESCE, PostgreSQLParserDEC, PostgreSQLParserDECIMAL_P, PostgreSQLParserEXISTS, PostgreSQLParserEXTRACT, PostgreSQLParserFLOAT_P, PostgreSQLParserGREATEST, PostgreSQLParserINOUT, PostgreSQLParserINT_P, PostgreSQLParserINTEGER, PostgreSQLParserINTERVAL, PostgreSQLParserLEAST, PostgreSQLParserNATIONAL, PostgreSQLParserNCHAR, PostgreSQLParserNONE, PostgreSQLParserNULLIF, PostgreSQLParserNUMERIC, PostgreSQLParserOVERLAY, PostgreSQLParserPOSITION, PostgreSQLParserPRECISION, PostgreSQLParserREAL, PostgreSQLParserROW, PostgreSQLParserSETOF, PostgreSQLParserSMALLINT, PostgreSQLParserSUBSTRING, PostgreSQLParserTIME, PostgreSQLParserTIMESTAMP, PostgreSQLParserTREAT, PostgreSQLParserTRIM, PostgreSQLParserVALUES, PostgreSQLParserVARCHAR, PostgreSQLParserXMLATTRIBUTES, PostgreSQLParserXMLCOMMENT, PostgreSQLParserXMLAGG, PostgreSQLParserXML_IS_WELL_FORMED, PostgreSQLParserXML_IS_WELL_FORMED_DOCUMENT, PostgreSQLParserXML_IS_WELL_FORMED_CONTENT, PostgreSQLParserXPATH, PostgreSQLParserXPATH_EXISTS, PostgreSQLParserXMLCONCAT, PostgreSQLParserXMLELEMENT, PostgreSQLParserXMLEXISTS, PostgreSQLParserXMLFOREST, PostgreSQLParserXMLPARSE, PostgreSQLParserXMLPI, PostgreSQLParserXMLROOT, PostgreSQLParserXMLSERIALIZE, PostgreSQLParserCALL, PostgreSQLParserCURRENT_P, PostgreSQLParserATTACH, PostgreSQLParserDETACH, PostgreSQLParserEXPRESSION, PostgreSQLParserGENERATED, PostgreSQLParserLOGGED, PostgreSQLParserSTORED, PostgreSQLParserINCLUDE, PostgreSQLParserROUTINE, PostgreSQLParserTRANSFORM, PostgreSQLParserIMPORT_P, PostgreSQLParserPOLICY, PostgreSQLParserMETHOD, PostgreSQLParserREFERENCING, PostgreSQLParserNEW, PostgreSQLParserOLD, PostgreSQLParserVALUE_P, PostgreSQLParserSUBSCRIPTION, PostgreSQLParserPUBLICATION, PostgreSQLParserOUT_P, PostgreSQLParserROUTINES, PostgreSQLParserSCHEMAS, PostgreSQLParserPROCEDURES, PostgreSQLParserINPUT_P, PostgreSQLParserSUPPORT, PostgreSQLParserPARALLEL, PostgreSQLParserSQL_P, PostgreSQLParserDEPENDS, PostgreSQLParserOVERRIDING, PostgreSQLParserCONFLICT, PostgreSQLParserSKIP_P, PostgreSQLParserLOCKED, PostgreSQLParserTIES, PostgreSQLParserROLLUP, PostgreSQLParserCUBE, PostgreSQLParserGROUPING, PostgreSQLParserSETS, PostgreSQLParserORDINALITY, PostgreSQLParserXMLTABLE, PostgreSQLParserCOLUMNS, PostgreSQLParserXMLNAMESPACES, PostgreSQLParserROWTYPE, PostgreSQLParserNORMALIZED, PostgreSQLParserWITHIN, PostgreSQLParserFILTER, PostgreSQLParserGROUPS, PostgreSQLParserOTHERS, PostgreSQLParserNFC, PostgreSQLParserNFD, PostgreSQLParserNFKC, PostgreSQLParserNFKD, PostgreSQLParserUESCAPE, PostgreSQLParserVIEWS, PostgreSQLParserNORMALIZE, PostgreSQLParserDUMP, PostgreSQLParserPRINT_STRICT_PARAMS, PostgreSQLParserVARIABLE_CONFLICT, PostgreSQLParserERROR, PostgreSQLParserUSE_VARIABLE, PostgreSQLParserUSE_COLUMN, PostgreSQLParserALIAS, PostgreSQLParserCONSTANT, PostgreSQLParserPERFORM, PostgreSQLParserGET, PostgreSQLParserDIAGNOSTICS, PostgreSQLParserSTACKED, PostgreSQLParserELSIF, PostgreSQLParserREVERSE, PostgreSQLParserSLICE, PostgreSQLParserEXIT, PostgreSQLParserRETURN, PostgreSQLParserQUERY, PostgreSQLParserRAISE, PostgreSQLParserSQLSTATE, PostgreSQLParserDEBUG, PostgreSQLParserLOG, PostgreSQLParserINFO, PostgreSQLParserNOTICE, PostgreSQLParserWARNING, PostgreSQLParserEXCEPTION, PostgreSQLParserASSERT, PostgreSQLParserOPEN, PostgreSQLParserABS, PostgreSQLParserCBRT, PostgreSQLParserCEIL, PostgreSQLParserCEILING, PostgreSQLParserDEGREES, PostgreSQLParserDIV, PostgreSQLParserEXP, PostgreSQLParserFACTORIAL, PostgreSQLParserFLOOR, PostgreSQLParserGCD, PostgreSQLParserLCM, PostgreSQLParserLN, PostgreSQLParserLOG10, PostgreSQLParserMIN_SCALE, PostgreSQLParserMOD, PostgreSQLParserPI, PostgreSQLParserPOWER, PostgreSQLParserRADIANS, PostgreSQLParserROUND, PostgreSQLParserSCALE, PostgreSQLParserSIGN, PostgreSQLParserSQRT, PostgreSQLParserTRIM_SCALE, PostgreSQLParserTRUNC, PostgreSQLParserWIDTH_BUCKET, PostgreSQLParserRANDOM, PostgreSQLParserSETSEED, PostgreSQLParserACOS, PostgreSQLParserACOSD, PostgreSQLParserASIN, PostgreSQLParserASIND, PostgreSQLParserATAN, PostgreSQLParserATAND, PostgreSQLParserATAN2, PostgreSQLParserATAN2D, PostgreSQLParserCOS, PostgreSQLParserCOSD, PostgreSQLParserCOT, PostgreSQLParserCOTD, PostgreSQLParserSIN, PostgreSQLParserSIND, PostgreSQLParserTAN, PostgreSQLParserTAND, PostgreSQLParserSINH, PostgreSQLParserCOSH, PostgreSQLParserTANH, PostgreSQLParserASINH, PostgreSQLParserACOSH, PostgreSQLParserATANH, PostgreSQLParserBIT_LENGTH, PostgreSQLParserCHAR_LENGTH, PostgreSQLParserCHARACTER_LENGTH, PostgreSQLParserLOWER, PostgreSQLParserOCTET_LENGTH, PostgreSQLParserUPPER, PostgreSQLParserASCII, PostgreSQLParserBTRIM, PostgreSQLParserCHR, PostgreSQLParserCONCAT, PostgreSQLParserCONCAT_WS, PostgreSQLParserFORMAT, PostgreSQLParserINITCAP, PostgreSQLParserLENGTH, PostgreSQLParserLPAD, PostgreSQLParserLTRIM, PostgreSQLParserMD5, PostgreSQLParserPARSE_IDENT, PostgreSQLParserPG_CLIENT_ENCODING, PostgreSQLParserQUOTE_IDENT, PostgreSQLParserQUOTE_LITERAL, PostgreSQLParserQUOTE_NULLABLE, PostgreSQLParserREGEXP_COUNT, PostgreSQLParserREGEXP_INSTR, PostgreSQLParserREGEXP_LIKE, PostgreSQLParserREGEXP_MATCH, PostgreSQLParserREGEXP_MATCHES, PostgreSQLParserREGEXP_REPLACE, PostgreSQLParserREGEXP_SPLIT_TO_ARRAY, PostgreSQLParserREGEXP_SPLIT_TO_TABLE, PostgreSQLParserREGEXP_SUBSTR, PostgreSQLParserREPEAT, PostgreSQLParserRPAD, PostgreSQLParserRTRIM, PostgreSQLParserSPLIT_PART, PostgreSQLParserSTARTS_WITH, PostgreSQLParserSTRING_TO_ARRAY, PostgreSQLParserSTRING_TO_TABLE, PostgreSQLParserSTRPOS, PostgreSQLParserSUBSTR, PostgreSQLParserTO_ASCII, PostgreSQLParserTO_HEX, PostgreSQLParserTRANSLATE, PostgreSQLParserUNISTR, PostgreSQLParserAGE, PostgreSQLParserCLOCK_TIMESTAMP, PostgreSQLParserDATE_BIN, PostgreSQLParserDATE_PART, PostgreSQLParserDATE_TRUNC, PostgreSQLParserISFINITE, PostgreSQLParserJUSTIFY_DAYS, PostgreSQLParserJUSTIFY_HOURS, PostgreSQLParserJUSTIFY_INTERVAL, PostgreSQLParserMAKE_DATE, PostgreSQLParserMAKE_INTERVAL, PostgreSQLParserMAKE_TIME, PostgreSQLParserMAKE_TIMESTAMP, PostgreSQLParserMAKE_TIMESTAMPTZ, PostgreSQLParserNOW, PostgreSQLParserSTATEMENT_TIMESTAMP, PostgreSQLParserTIMEOFDAY, PostgreSQLParserTRANSACTION_TIMESTAMP, PostgreSQLParserTO_TIMESTAMP, PostgreSQLParserTO_CHAR, PostgreSQLParserTO_DATE, PostgreSQLParserTO_NUMBER, PostgreSQLParserIdentifier, PostgreSQLParserQuotedIdentifier, PostgreSQLParserUnicodeQuotedIdentifier, PostgreSQLParserPLSQLVARIABLENAME, PostgreSQLParserPLSQLIDENTIFIER:
		{
			p.SetState(2615)
			p.Cursor_name()
		}

	case PostgreSQLParserALL:
		{
			p.SetState(2616)
			p.Match(PostgreSQLParserALL)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	default:
		p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// ICopystmtContext is an interface to support dynamic dispatch.
type ICopystmtContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	COPY() antlr.TerminalNode
	Opt_binary() IOpt_binaryContext
	Qualified_name() IQualified_nameContext
	Opt_column_list() IOpt_column_listContext
	Copy_from() ICopy_fromContext
	Opt_program() IOpt_programContext
	Copy_file_name() ICopy_file_nameContext
	Copy_delimiter() ICopy_delimiterContext
	Opt_with() IOpt_withContext
	Copy_options() ICopy_optionsContext
	Where_clause() IWhere_clauseContext
	OPEN_PAREN() antlr.TerminalNode
	Preparablestmt() IPreparablestmtContext
	CLOSE_PAREN() antlr.TerminalNode
	TO() antlr.TerminalNode

	// IsCopystmtContext differentiates from other interfaces.
	IsCopystmtContext()
}

type CopystmtContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyCopystmtContext() *CopystmtContext {
	var p = new(CopystmtContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_copystmt
	return p
}

func InitEmptyCopystmtContext(p *CopystmtContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_copystmt
}

func (*CopystmtContext) IsCopystmtContext() {}

func NewCopystmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CopystmtContext {
	var p = new(CopystmtContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_copystmt

	return p
}

func (s *CopystmtContext) GetParser() antlr.Parser { return s.parser }

func (s *CopystmtContext) COPY() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCOPY, 0)
}

func (s *CopystmtContext) Opt_binary() IOpt_binaryContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOpt_binaryContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOpt_binaryContext)
}

func (s *CopystmtContext) Qualified_name() IQualified_nameContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IQualified_nameContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IQualified_nameContext)
}

func (s *CopystmtContext) Opt_column_list() IOpt_column_listContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOpt_column_listContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOpt_column_listContext)
}

func (s *CopystmtContext) Copy_from() ICopy_fromContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ICopy_fromContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ICopy_fromContext)
}

func (s *CopystmtContext) Opt_program() IOpt_programContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOpt_programContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOpt_programContext)
}

func (s *CopystmtContext) Copy_file_name() ICopy_file_nameContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ICopy_file_nameContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ICopy_file_nameContext)
}

func (s *CopystmtContext) Copy_delimiter() ICopy_delimiterContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ICopy_delimiterContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ICopy_delimiterContext)
}

func (s *CopystmtContext) Opt_with() IOpt_withContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOpt_withContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOpt_withContext)
}

func (s *CopystmtContext) Copy_options() ICopy_optionsContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ICopy_optionsContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ICopy_optionsContext)
}

func (s *CopystmtContext) Where_clause() IWhere_clauseContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IWhere_clauseContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IWhere_clauseContext)
}

func (s *CopystmtContext) OPEN_PAREN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserOPEN_PAREN, 0)
}

func (s *CopystmtContext) Preparablestmt() IPreparablestmtContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IPreparablestmtContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IPreparablestmtContext)
}

func (s *CopystmtContext) CLOSE_PAREN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCLOSE_PAREN, 0)
}

func (s *CopystmtContext) TO() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserTO, 0)
}

func (s *CopystmtContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *CopystmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *CopystmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterCopystmt(s)
	}
}

func (s *CopystmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitCopystmt(s)
	}
}

func (s *CopystmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitCopystmt(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Copystmt() (localctx ICopystmtContext) {
	localctx = NewCopystmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 142, PostgreSQLParserRULE_copystmt)
	p.SetState(2641)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 69, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(2619)
			p.Match(PostgreSQLParserCOPY)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2620)
			p.Opt_binary()
		}
		{
			p.SetState(2621)
			p.Qualified_name()
		}
		{
			p.SetState(2622)
			p.Opt_column_list()
		}
		{
			p.SetState(2623)
			p.Copy_from()
		}
		{
			p.SetState(2624)
			p.Opt_program()
		}
		{
			p.SetState(2625)
			p.Copy_file_name()
		}
		{
			p.SetState(2626)
			p.Copy_delimiter()
		}
		{
			p.SetState(2627)
			p.Opt_with()
		}
		{
			p.SetState(2628)
			p.Copy_options()
		}
		{
			p.SetState(2629)
			p.Where_clause()
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(2631)
			p.Match(PostgreSQLParserCOPY)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2632)
			p.Match(PostgreSQLParserOPEN_PAREN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2633)
			p.Preparablestmt()
		}
		{
			p.SetState(2634)
			p.Match(PostgreSQLParserCLOSE_PAREN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2635)
			p.Match(PostgreSQLParserTO)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2636)
			p.Opt_program()
		}
		{
			p.SetState(2637)
			p.Copy_file_name()
		}
		{
			p.SetState(2638)
			p.Opt_with()
		}
		{
			p.SetState(2639)
			p.Copy_options()
		}

	case antlr.ATNInvalidAltNumber:
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// ICopy_fromContext is an interface to support dynamic dispatch.
type ICopy_fromContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	FROM() antlr.TerminalNode
	TO() antlr.TerminalNode

	// IsCopy_fromContext differentiates from other interfaces.
	IsCopy_fromContext()
}

type Copy_fromContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyCopy_fromContext() *Copy_fromContext {
	var p = new(Copy_fromContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_copy_from
	return p
}

func InitEmptyCopy_fromContext(p *Copy_fromContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_copy_from
}

func (*Copy_fromContext) IsCopy_fromContext() {}

func NewCopy_fromContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Copy_fromContext {
	var p = new(Copy_fromContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_copy_from

	return p
}

func (s *Copy_fromContext) GetParser() antlr.Parser { return s.parser }

func (s *Copy_fromContext) FROM() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserFROM, 0)
}

func (s *Copy_fromContext) TO() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserTO, 0)
}

func (s *Copy_fromContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Copy_fromContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Copy_fromContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterCopy_from(s)
	}
}

func (s *Copy_fromContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitCopy_from(s)
	}
}

func (s *Copy_fromContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitCopy_from(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Copy_from() (localctx ICopy_fromContext) {
	localctx = NewCopy_fromContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 144, PostgreSQLParserRULE_copy_from)
	var _la int

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(2643)
		_la = p.GetTokenStream().LA(1)

		if !(_la == PostgreSQLParserFROM || _la == PostgreSQLParserTO) {
			p.GetErrorHandler().RecoverInline(p)
		} else {
			p.GetErrorHandler().ReportMatch(p)
			p.Consume()
		}
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IOpt_programContext is an interface to support dynamic dispatch.
type IOpt_programContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	PROGRAM() antlr.TerminalNode

	// IsOpt_programContext differentiates from other interfaces.
	IsOpt_programContext()
}

type Opt_programContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyOpt_programContext() *Opt_programContext {
	var p = new(Opt_programContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opt_program
	return p
}

func InitEmptyOpt_programContext(p *Opt_programContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opt_program
}

func (*Opt_programContext) IsOpt_programContext() {}

func NewOpt_programContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_programContext {
	var p = new(Opt_programContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_opt_program

	return p
}

func (s *Opt_programContext) GetParser() antlr.Parser { return s.parser }

func (s *Opt_programContext) PROGRAM() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserPROGRAM, 0)
}

func (s *Opt_programContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Opt_programContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Opt_programContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterOpt_program(s)
	}
}

func (s *Opt_programContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitOpt_program(s)
	}
}

func (s *Opt_programContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitOpt_program(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Opt_program() (localctx IOpt_programContext) {
	localctx = NewOpt_programContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 146, PostgreSQLParserRULE_opt_program)
	p.SetState(2647)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetTokenStream().LA(1) {
	case PostgreSQLParserPROGRAM:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(2645)
			p.Match(PostgreSQLParserPROGRAM)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case PostgreSQLParserSTDIN, PostgreSQLParserSTDOUT, PostgreSQLParserStringConstant, PostgreSQLParserUnicodeEscapeStringConstant, PostgreSQLParserBeginDollarStringConstant, PostgreSQLParserEscapeStringConstant:
		p.EnterOuterAlt(localctx, 2)

	default:
		p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// ICopy_file_nameContext is an interface to support dynamic dispatch.
type ICopy_file_nameContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Sconst() ISconstContext
	STDIN() antlr.TerminalNode
	STDOUT() antlr.TerminalNode

	// IsCopy_file_nameContext differentiates from other interfaces.
	IsCopy_file_nameContext()
}

type Copy_file_nameContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyCopy_file_nameContext() *Copy_file_nameContext {
	var p = new(Copy_file_nameContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_copy_file_name
	return p
}

func InitEmptyCopy_file_nameContext(p *Copy_file_nameContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_copy_file_name
}

func (*Copy_file_nameContext) IsCopy_file_nameContext() {}

func NewCopy_file_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Copy_file_nameContext {
	var p = new(Copy_file_nameContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_copy_file_name

	return p
}

func (s *Copy_file_nameContext) GetParser() antlr.Parser { return s.parser }

func (s *Copy_file_nameContext) Sconst() ISconstContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ISconstContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ISconstContext)
}

func (s *Copy_file_nameContext) STDIN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserSTDIN, 0)
}

func (s *Copy_file_nameContext) STDOUT() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserSTDOUT, 0)
}

func (s *Copy_file_nameContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Copy_file_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Copy_file_nameContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterCopy_file_name(s)
	}
}

func (s *Copy_file_nameContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitCopy_file_name(s)
	}
}

func (s *Copy_file_nameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitCopy_file_name(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Copy_file_name() (localctx ICopy_file_nameContext) {
	localctx = NewCopy_file_nameContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 148, PostgreSQLParserRULE_copy_file_name)
	p.SetState(2652)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetTokenStream().LA(1) {
	case PostgreSQLParserStringConstant, PostgreSQLParserUnicodeEscapeStringConstant, PostgreSQLParserBeginDollarStringConstant, PostgreSQLParserEscapeStringConstant:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(2649)
			p.Sconst()
		}

	case PostgreSQLParserSTDIN:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(2650)
			p.Match(PostgreSQLParserSTDIN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case PostgreSQLParserSTDOUT:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(2651)
			p.Match(PostgreSQLParserSTDOUT)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	default:
		p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// ICopy_optionsContext is an interface to support dynamic dispatch.
type ICopy_optionsContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Copy_opt_list() ICopy_opt_listContext
	OPEN_PAREN() antlr.TerminalNode
	Copy_generic_opt_list() ICopy_generic_opt_listContext
	CLOSE_PAREN() antlr.TerminalNode

	// IsCopy_optionsContext differentiates from other interfaces.
	IsCopy_optionsContext()
}

type Copy_optionsContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyCopy_optionsContext() *Copy_optionsContext {
	var p = new(Copy_optionsContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_copy_options
	return p
}

func InitEmptyCopy_optionsContext(p *Copy_optionsContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_copy_options
}

func (*Copy_optionsContext) IsCopy_optionsContext() {}

func NewCopy_optionsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Copy_optionsContext {
	var p = new(Copy_optionsContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_copy_options

	return p
}

func (s *Copy_optionsContext) GetParser() antlr.Parser { return s.parser }

func (s *Copy_optionsContext) Copy_opt_list() ICopy_opt_listContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ICopy_opt_listContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ICopy_opt_listContext)
}

func (s *Copy_optionsContext) OPEN_PAREN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserOPEN_PAREN, 0)
}

func (s *Copy_optionsContext) Copy_generic_opt_list() ICopy_generic_opt_listContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ICopy_generic_opt_listContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ICopy_generic_opt_listContext)
}

func (s *Copy_optionsContext) CLOSE_PAREN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCLOSE_PAREN, 0)
}

func (s *Copy_optionsContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Copy_optionsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Copy_optionsContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterCopy_options(s)
	}
}

func (s *Copy_optionsContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitCopy_options(s)
	}
}

func (s *Copy_optionsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitCopy_options(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Copy_options() (localctx ICopy_optionsContext) {
	localctx = NewCopy_optionsContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 150, PostgreSQLParserRULE_copy_options)
	p.SetState(2659)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 72, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(2654)
			p.Copy_opt_list()
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(2655)
			p.Match(PostgreSQLParserOPEN_PAREN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2656)
			p.Copy_generic_opt_list()
		}
		{
			p.SetState(2657)
			p.Match(PostgreSQLParserCLOSE_PAREN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case antlr.ATNInvalidAltNumber:
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// ICopy_opt_listContext is an interface to support dynamic dispatch.
type ICopy_opt_listContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	AllCopy_opt_item() []ICopy_opt_itemContext
	Copy_opt_item(i int) ICopy_opt_itemContext

	// IsCopy_opt_listContext differentiates from other interfaces.
	IsCopy_opt_listContext()
}

type Copy_opt_listContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyCopy_opt_listContext() *Copy_opt_listContext {
	var p = new(Copy_opt_listContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_copy_opt_list
	return p
}

func InitEmptyCopy_opt_listContext(p *Copy_opt_listContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_copy_opt_list
}

func (*Copy_opt_listContext) IsCopy_opt_listContext() {}

func NewCopy_opt_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Copy_opt_listContext {
	var p = new(Copy_opt_listContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_copy_opt_list

	return p
}

func (s *Copy_opt_listContext) GetParser() antlr.Parser { return s.parser }

func (s *Copy_opt_listContext) AllCopy_opt_item() []ICopy_opt_itemContext {
	children := s.GetChildren()
	len := 0
	for _, ctx := range children {
		if _, ok := ctx.(ICopy_opt_itemContext); ok {
			len++
		}
	}

	tst := make([]ICopy_opt_itemContext, len)
	i := 0
	for _, ctx := range children {
		if t, ok := ctx.(ICopy_opt_itemContext); ok {
			tst[i] = t.(ICopy_opt_itemContext)
			i++
		}
	}

	return tst
}

func (s *Copy_opt_listContext) Copy_opt_item(i int) ICopy_opt_itemContext {
	var t antlr.RuleContext
	j := 0
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ICopy_opt_itemContext); ok {
			if j == i {
				t = ctx.(antlr.RuleContext)
				break
			}
			j++
		}
	}

	if t == nil {
		return nil
	}

	return t.(ICopy_opt_itemContext)
}

func (s *Copy_opt_listContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Copy_opt_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Copy_opt_listContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterCopy_opt_list(s)
	}
}

func (s *Copy_opt_listContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitCopy_opt_list(s)
	}
}

func (s *Copy_opt_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitCopy_opt_list(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Copy_opt_list() (localctx ICopy_opt_listContext) {
	localctx = NewCopy_opt_listContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 152, PostgreSQLParserRULE_copy_opt_list)
	var _la int

	p.EnterOuterAlt(localctx, 1)
	p.SetState(2664)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}
	_la = p.GetTokenStream().LA(1)

	for ((int64((_la-78)) & ^0x3f) == 0 && ((int64(1)<<(_la-78))&17716740097) != 0) || ((int64((_la-171)) & ^0x3f) == 0 && ((int64(1)<<(_la-171))&35459325497345) != 0) || _la == PostgreSQLParserQUOTE {
		{
			p.SetState(2661)
			p.Copy_opt_item()
		}

		p.SetState(2666)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}
		_la = p.GetTokenStream().LA(1)
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// ICopy_opt_itemContext is an interface to support dynamic dispatch.
type ICopy_opt_itemContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	BINARY() antlr.TerminalNode
	FREEZE() antlr.TerminalNode
	DELIMITER() antlr.TerminalNode
	Opt_as() IOpt_asContext
	Sconst() ISconstContext
	NULL_P() antlr.TerminalNode
	CSV() antlr.TerminalNode
	HEADER_P() antlr.TerminalNode
	QUOTE() antlr.TerminalNode
	ESCAPE() antlr.TerminalNode
	FORCE() antlr.TerminalNode
	Columnlist() IColumnlistContext
	STAR() antlr.TerminalNode
	NOT() antlr.TerminalNode
	ENCODING() antlr.TerminalNode

	// IsCopy_opt_itemContext differentiates from other interfaces.
	IsCopy_opt_itemContext()
}

type Copy_opt_itemContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyCopy_opt_itemContext() *Copy_opt_itemContext {
	var p = new(Copy_opt_itemContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_copy_opt_item
	return p
}

func InitEmptyCopy_opt_itemContext(p *Copy_opt_itemContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_copy_opt_item
}

func (*Copy_opt_itemContext) IsCopy_opt_itemContext() {}

func NewCopy_opt_itemContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Copy_opt_itemContext {
	var p = new(Copy_opt_itemContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_copy_opt_item

	return p
}

func (s *Copy_opt_itemContext) GetParser() antlr.Parser { return s.parser }

func (s *Copy_opt_itemContext) BINARY() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserBINARY, 0)
}

func (s *Copy_opt_itemContext) FREEZE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserFREEZE, 0)
}

func (s *Copy_opt_itemContext) DELIMITER() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserDELIMITER, 0)
}

func (s *Copy_opt_itemContext) Opt_as() IOpt_asContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOpt_asContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOpt_asContext)
}

func (s *Copy_opt_itemContext) Sconst() ISconstContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ISconstContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ISconstContext)
}

func (s *Copy_opt_itemContext) NULL_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserNULL_P, 0)
}

func (s *Copy_opt_itemContext) CSV() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCSV, 0)
}

func (s *Copy_opt_itemContext) HEADER_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserHEADER_P, 0)
}

func (s *Copy_opt_itemContext) QUOTE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserQUOTE, 0)
}

func (s *Copy_opt_itemContext) ESCAPE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserESCAPE, 0)
}

func (s *Copy_opt_itemContext) FORCE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserFORCE, 0)
}

func (s *Copy_opt_itemContext) Columnlist() IColumnlistContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IColumnlistContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IColumnlistContext)
}

func (s *Copy_opt_itemContext) STAR() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserSTAR, 0)
}

func (s *Copy_opt_itemContext) NOT() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserNOT, 0)
}

func (s *Copy_opt_itemContext) ENCODING() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserENCODING, 0)
}

func (s *Copy_opt_itemContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Copy_opt_itemContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Copy_opt_itemContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterCopy_opt_item(s)
	}
}

func (s *Copy_opt_itemContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitCopy_opt_item(s)
	}
}

func (s *Copy_opt_itemContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitCopy_opt_item(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Copy_opt_item() (localctx ICopy_opt_itemContext) {
	localctx = NewCopy_opt_itemContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 154, PostgreSQLParserRULE_copy_opt_item)
	p.SetState(2702)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 74, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(2667)
			p.Match(PostgreSQLParserBINARY)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(2668)
			p.Match(PostgreSQLParserFREEZE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 3:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(2669)
			p.Match(PostgreSQLParserDELIMITER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2670)
			p.Opt_as()
		}
		{
			p.SetState(2671)
			p.Sconst()
		}

	case 4:
		p.EnterOuterAlt(localctx, 4)
		{
			p.SetState(2673)
			p.Match(PostgreSQLParserNULL_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2674)
			p.Opt_as()
		}
		{
			p.SetState(2675)
			p.Sconst()
		}

	case 5:
		p.EnterOuterAlt(localctx, 5)
		{
			p.SetState(2677)
			p.Match(PostgreSQLParserCSV)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 6:
		p.EnterOuterAlt(localctx, 6)
		{
			p.SetState(2678)
			p.Match(PostgreSQLParserHEADER_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 7:
		p.EnterOuterAlt(localctx, 7)
		{
			p.SetState(2679)
			p.Match(PostgreSQLParserQUOTE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2680)
			p.Opt_as()
		}
		{
			p.SetState(2681)
			p.Sconst()
		}

	case 8:
		p.EnterOuterAlt(localctx, 8)
		{
			p.SetState(2683)
			p.Match(PostgreSQLParserESCAPE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2684)
			p.Opt_as()
		}
		{
			p.SetState(2685)
			p.Sconst()
		}

	case 9:
		p.EnterOuterAlt(localctx, 9)
		{
			p.SetState(2687)
			p.Match(PostgreSQLParserFORCE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2688)
			p.Match(PostgreSQLParserQUOTE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2689)
			p.Columnlist()
		}

	case 10:
		p.EnterOuterAlt(localctx, 10)
		{
			p.SetState(2690)
			p.Match(PostgreSQLParserFORCE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2691)
			p.Match(PostgreSQLParserQUOTE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2692)
			p.Match(PostgreSQLParserSTAR)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 11:
		p.EnterOuterAlt(localctx, 11)
		{
			p.SetState(2693)
			p.Match(PostgreSQLParserFORCE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2694)
			p.Match(PostgreSQLParserNOT)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2695)
			p.Match(PostgreSQLParserNULL_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2696)
			p.Columnlist()
		}

	case 12:
		p.EnterOuterAlt(localctx, 12)
		{
			p.SetState(2697)
			p.Match(PostgreSQLParserFORCE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2698)
			p.Match(PostgreSQLParserNULL_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2699)
			p.Columnlist()
		}

	case 13:
		p.EnterOuterAlt(localctx, 13)
		{
			p.SetState(2700)
			p.Match(PostgreSQLParserENCODING)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2701)
			p.Sconst()
		}

	case antlr.ATNInvalidAltNumber:
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IOpt_binaryContext is an interface to support dynamic dispatch.
type IOpt_binaryContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	BINARY() antlr.TerminalNode

	// IsOpt_binaryContext differentiates from other interfaces.
	IsOpt_binaryContext()
}

type Opt_binaryContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyOpt_binaryContext() *Opt_binaryContext {
	var p = new(Opt_binaryContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opt_binary
	return p
}

func InitEmptyOpt_binaryContext(p *Opt_binaryContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opt_binary
}

func (*Opt_binaryContext) IsOpt_binaryContext() {}

func NewOpt_binaryContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_binaryContext {
	var p = new(Opt_binaryContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_opt_binary

	return p
}

func (s *Opt_binaryContext) GetParser() antlr.Parser { return s.parser }

func (s *Opt_binaryContext) BINARY() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserBINARY, 0)
}

func (s *Opt_binaryContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Opt_binaryContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Opt_binaryContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterOpt_binary(s)
	}
}

func (s *Opt_binaryContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitOpt_binary(s)
	}
}

func (s *Opt_binaryContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitOpt_binary(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Opt_binary() (localctx IOpt_binaryContext) {
	localctx = NewOpt_binaryContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 156, PostgreSQLParserRULE_opt_binary)
	p.SetState(2706)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetTokenStream().LA(1) {
	case PostgreSQLParserBINARY:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(2704)
			p.Match(PostgreSQLParserBINARY)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case PostgreSQLParserAND, PostgreSQLParserARRAY, PostgreSQLParserCOLLATE, PostgreSQLParserCOLUMN, PostgreSQLParserCONSTRAINT, PostgreSQLParserDEFAULT, PostgreSQLParserDO, PostgreSQLParserFETCH, PostgreSQLParserTABLE, PostgreSQLParserIS, PostgreSQLParserLEFT, PostgreSQLParserOUTER_P, PostgreSQLParserOVER, PostgreSQLParserRIGHT, PostgreSQLParserABORT_P, PostgreSQLParserABSOLUTE_P, PostgreSQLParserACCESS, PostgreSQLParserACTION, PostgreSQLParserADD_P, PostgreSQLParserADMIN, PostgreSQLParserAFTER, PostgreSQLParserAGGREGATE, PostgreSQLParserALSO, PostgreSQLParserALTER, PostgreSQLParserALWAYS, PostgreSQLParserASSERTION, PostgreSQLParserASSIGNMENT, PostgreSQLParserAT, PostgreSQLParserATTRIBUTE, PostgreSQLParserBACKWARD, PostgreSQLParserBEFORE, PostgreSQLParserBEGIN_P, PostgreSQLParserBY, PostgreSQLParserCACHE, PostgreSQLParserCALLED, PostgreSQLParserCASCADE, PostgreSQLParserCASCADED, PostgreSQLParserCATALOG, PostgreSQLParserCHAIN, PostgreSQLParserCHARACTERISTICS, PostgreSQLParserCHECKPOINT, PostgreSQLParserCLASS, PostgreSQLParserCLOSE, PostgreSQLParserCLUSTER, PostgreSQLParserCOMMENT, PostgreSQLParserCOMMENTS, PostgreSQLParserCOMMIT, PostgreSQLParserCOMMITTED, PostgreSQLParserCONFIGURATION, PostgreSQLParserCONNECTION, PostgreSQLParserCONSTRAINTS, PostgreSQLParserCONTENT_P, PostgreSQLParserCONTINUE_P, PostgreSQLParserCONVERSION_P, PostgreSQLParserCOPY, PostgreSQLParserCOST, PostgreSQLParserCSV, PostgreSQLParserCURSOR, PostgreSQLParserCYCLE, PostgreSQLParserDATA_P, PostgreSQLParserDATABASE, PostgreSQLParserDAY_P, PostgreSQLParserDEALLOCATE, PostgreSQLParserDECLARE, PostgreSQLParserDEFAULTS, PostgreSQLParserDEFERRED, PostgreSQLParserDEFINER, PostgreSQLParserDELETE_P, PostgreSQLParserDELIMITER, PostgreSQLParserDELIMITERS, PostgreSQLParserDICTIONARY, PostgreSQLParserDISABLE_P, PostgreSQLParserDISCARD, PostgreSQLParserDOCUMENT_P, PostgreSQLParserDOMAIN_P, PostgreSQLParserDOUBLE_P, PostgreSQLParserDROP, PostgreSQLParserEACH, PostgreSQLParserENABLE_P, PostgreSQLParserENCODING, PostgreSQLParserENCRYPTED, PostgreSQLParserENUM_P, PostgreSQLParserESCAPE, PostgreSQLParserEVENT, PostgreSQLParserEXCLUDE, PostgreSQLParserEXCLUDING, PostgreSQLParserEXCLUSIVE, PostgreSQLParserEXECUTE, PostgreSQLParserEXPLAIN, PostgreSQLParserEXTENSION, PostgreSQLParserEXTERNAL, PostgreSQLParserFAMILY, PostgreSQLParserFIRST_P, PostgreSQLParserFOLLOWING, PostgreSQLParserFORCE, PostgreSQLParserFORWARD, PostgreSQLParserFUNCTION, PostgreSQLParserFUNCTIONS, PostgreSQLParserGLOBAL, PostgreSQLParserGRANTED, PostgreSQLParserHANDLER, PostgreSQLParserHEADER_P, PostgreSQLParserHOLD, PostgreSQLParserHOUR_P, PostgreSQLParserIDENTITY_P, PostgreSQLParserIF_P, PostgreSQLParserIMMEDIATE, PostgreSQLParserIMMUTABLE, PostgreSQLParserIMPLICIT_P, PostgreSQLParserINCLUDING, PostgreSQLParserINCREMENT, PostgreSQLParserINDEX, PostgreSQLParserINDEXES, PostgreSQLParserINHERIT, PostgreSQLParserINHERITS, PostgreSQLParserINLINE_P, PostgreSQLParserINSENSITIVE, PostgreSQLParserINSERT, PostgreSQLParserINSTEAD, PostgreSQLParserINVOKER, PostgreSQLParserISOLATION, PostgreSQLParserKEY, PostgreSQLParserLABEL, PostgreSQLParserLANGUAGE, PostgreSQLParserLARGE_P, PostgreSQLParserLAST_P, PostgreSQLParserLEAKPROOF, PostgreSQLParserLEVEL, PostgreSQLParserLISTEN, PostgreSQLParserLOAD, PostgreSQLParserLOCAL, PostgreSQLParserLOCATION, PostgreSQLParserLOCK_P, PostgreSQLParserMAPPING, PostgreSQLParserMATCH, PostgreSQLParserMATERIALIZED, PostgreSQLParserMAXVALUE, PostgreSQLParserMINUTE_P, PostgreSQLParserMINVALUE, PostgreSQLParserMODE, PostgreSQLParserMONTH_P, PostgreSQLParserMOVE, PostgreSQLParserNAME_P, PostgreSQLParserNAMES, PostgreSQLParserNEXT, PostgreSQLParserNO, PostgreSQLParserNOTHING, PostgreSQLParserNOTIFY, PostgreSQLParserNOWAIT, PostgreSQLParserNULLS_P, PostgreSQLParserOBJECT_P, PostgreSQLParserOF, PostgreSQLParserOFF, PostgreSQLParserOIDS, PostgreSQLParserOPERATOR, PostgreSQLParserOPTION, PostgreSQLParserOPTIONS, PostgreSQLParserOWNED, PostgreSQLParserOWNER, PostgreSQLParserPARSER, PostgreSQLParserPARTIAL, PostgreSQLParserPARTITION, PostgreSQLParserPASSING, PostgreSQLParserPASSWORD, PostgreSQLParserPLANS, PostgreSQLParserPRECEDING, PostgreSQLParserPREPARE, PostgreSQLParserPREPARED, PostgreSQLParserPRESERVE, PostgreSQLParserPRIOR, PostgreSQLParserPRIVILEGES, PostgreSQLParserPROCEDURAL, PostgreSQLParserPROCEDURE, PostgreSQLParserPROGRAM, PostgreSQLParserQUOTE, PostgreSQLParserRANGE, PostgreSQLParserREAD, PostgreSQLParserREASSIGN, PostgreSQLParserRECHECK, PostgreSQLParserRECURSIVE, PostgreSQLParserREF, PostgreSQLParserREFRESH, PostgreSQLParserREINDEX, PostgreSQLParserRELATIVE_P, PostgreSQLParserRELEASE, PostgreSQLParserRENAME, PostgreSQLParserREPEATABLE, PostgreSQLParserREPLACE, PostgreSQLParserREPLICA, PostgreSQLParserRESET, PostgreSQLParserRESTART, PostgreSQLParserRESTRICT, PostgreSQLParserRETURNS, PostgreSQLParserREVOKE, PostgreSQLParserROLE, PostgreSQLParserROLLBACK, PostgreSQLParserROWS, PostgreSQLParserRULE, PostgreSQLParserSAVEPOINT, PostgreSQLParserSCHEMA, PostgreSQLParserSCROLL, PostgreSQLParserSEARCH, PostgreSQLParserSECOND_P, PostgreSQLParserSECURITY, PostgreSQLParserSEQUENCE, PostgreSQLParserSEQUENCES, PostgreSQLParserSERIALIZABLE, PostgreSQLParserSERVER, PostgreSQLParserSESSION, PostgreSQLParserSET, PostgreSQLParserSHARE, PostgreSQLParserSHOW, PostgreSQLParserSIMPLE, PostgreSQLParserSNAPSHOT, PostgreSQLParserSTABLE, PostgreSQLParserSTANDALONE_P, PostgreSQLParserSTART, PostgreSQLParserSTATEMENT, PostgreSQLParserSTATISTICS, PostgreSQLParserSTDIN, PostgreSQLParserSTDOUT, PostgreSQLParserSTORAGE, PostgreSQLParserSTRICT_P, PostgreSQLParserSTRIP_P, PostgreSQLParserSYSID, PostgreSQLParserSYSTEM_P, PostgreSQLParserTABLES, PostgreSQLParserTABLESPACE, PostgreSQLParserTEMP, PostgreSQLParserTEMPLATE, PostgreSQLParserTEMPORARY, PostgreSQLParserTEXT_P, PostgreSQLParserTRANSACTION, PostgreSQLParserTRIGGER, PostgreSQLParserTRUNCATE, PostgreSQLParserTRUSTED, PostgreSQLParserTYPE_P, PostgreSQLParserTYPES_P, PostgreSQLParserUNBOUNDED, PostgreSQLParserUNCOMMITTED, PostgreSQLParserUNENCRYPTED, PostgreSQLParserUNKNOWN, PostgreSQLParserUNLISTEN, PostgreSQLParserUNLOGGED, PostgreSQLParserUNTIL, PostgreSQLParserUPDATE, PostgreSQLParserVACUUM, PostgreSQLParserVALID, PostgreSQLParserVALIDATE, PostgreSQLParserVALIDATOR, PostgreSQLParserVARYING, PostgreSQLParserVERSION_P, PostgreSQLParserVIEW, PostgreSQLParserVOLATILE, PostgreSQLParserWHITESPACE_P, PostgreSQLParserWITHOUT, PostgreSQLParserWORK, PostgreSQLParserWRAPPER, PostgreSQLParserWRITE, PostgreSQLParserXML_P, PostgreSQLParserYEAR_P, PostgreSQLParserYES_P, PostgreSQLParserZONE, PostgreSQLParserBETWEEN, PostgreSQLParserBIGINT, PostgreSQLParserBIT, PostgreSQLParserBOOLEAN_P, PostgreSQLParserCHAR_P, PostgreSQLParserCHARACTER, PostgreSQLParserCOALESCE, PostgreSQLParserDEC, PostgreSQLParserDECIMAL_P, PostgreSQLParserEXISTS, PostgreSQLParserEXTRACT, PostgreSQLParserFLOAT_P, PostgreSQLParserGREATEST, PostgreSQLParserINOUT, PostgreSQLParserINT_P, PostgreSQLParserINTEGER, PostgreSQLParserINTERVAL, PostgreSQLParserLEAST, PostgreSQLParserNATIONAL, PostgreSQLParserNCHAR, PostgreSQLParserNONE, PostgreSQLParserNULLIF, PostgreSQLParserNUMERIC, PostgreSQLParserOVERLAY, PostgreSQLParserPOSITION, PostgreSQLParserPRECISION, PostgreSQLParserREAL, PostgreSQLParserROW, PostgreSQLParserSETOF, PostgreSQLParserSMALLINT, PostgreSQLParserSUBSTRING, PostgreSQLParserTIME, PostgreSQLParserTIMESTAMP, PostgreSQLParserTREAT, PostgreSQLParserTRIM, PostgreSQLParserVALUES, PostgreSQLParserVARCHAR, PostgreSQLParserXMLATTRIBUTES, PostgreSQLParserXMLCOMMENT, PostgreSQLParserXMLAGG, PostgreSQLParserXML_IS_WELL_FORMED, PostgreSQLParserXML_IS_WELL_FORMED_DOCUMENT, PostgreSQLParserXML_IS_WELL_FORMED_CONTENT, PostgreSQLParserXPATH, PostgreSQLParserXPATH_EXISTS, PostgreSQLParserXMLCONCAT, PostgreSQLParserXMLELEMENT, PostgreSQLParserXMLEXISTS, PostgreSQLParserXMLFOREST, PostgreSQLParserXMLPARSE, PostgreSQLParserXMLPI, PostgreSQLParserXMLROOT, PostgreSQLParserXMLSERIALIZE, PostgreSQLParserCALL, PostgreSQLParserCURRENT_P, PostgreSQLParserATTACH, PostgreSQLParserDETACH, PostgreSQLParserEXPRESSION, PostgreSQLParserGENERATED, PostgreSQLParserLOGGED, PostgreSQLParserSTORED, PostgreSQLParserINCLUDE, PostgreSQLParserROUTINE, PostgreSQLParserTRANSFORM, PostgreSQLParserIMPORT_P, PostgreSQLParserPOLICY, PostgreSQLParserMETHOD, PostgreSQLParserREFERENCING, PostgreSQLParserNEW, PostgreSQLParserOLD, PostgreSQLParserVALUE_P, PostgreSQLParserSUBSCRIPTION, PostgreSQLParserPUBLICATION, PostgreSQLParserOUT_P, PostgreSQLParserROUTINES, PostgreSQLParserSCHEMAS, PostgreSQLParserPROCEDURES, PostgreSQLParserINPUT_P, PostgreSQLParserSUPPORT, PostgreSQLParserPARALLEL, PostgreSQLParserSQL_P, PostgreSQLParserDEPENDS, PostgreSQLParserOVERRIDING, PostgreSQLParserCONFLICT, PostgreSQLParserSKIP_P, PostgreSQLParserLOCKED, PostgreSQLParserTIES, PostgreSQLParserROLLUP, PostgreSQLParserCUBE, PostgreSQLParserGROUPING, PostgreSQLParserSETS, PostgreSQLParserORDINALITY, PostgreSQLParserXMLTABLE, PostgreSQLParserCOLUMNS, PostgreSQLParserXMLNAMESPACES, PostgreSQLParserROWTYPE, PostgreSQLParserNORMALIZED, PostgreSQLParserWITHIN, PostgreSQLParserFILTER, PostgreSQLParserGROUPS, PostgreSQLParserOTHERS, PostgreSQLParserNFC, PostgreSQLParserNFD, PostgreSQLParserNFKC, PostgreSQLParserNFKD, PostgreSQLParserUESCAPE, PostgreSQLParserVIEWS, PostgreSQLParserNORMALIZE, PostgreSQLParserDUMP, PostgreSQLParserPRINT_STRICT_PARAMS, PostgreSQLParserVARIABLE_CONFLICT, PostgreSQLParserERROR, PostgreSQLParserUSE_VARIABLE, PostgreSQLParserUSE_COLUMN, PostgreSQLParserALIAS, PostgreSQLParserCONSTANT, PostgreSQLParserPERFORM, PostgreSQLParserGET, PostgreSQLParserDIAGNOSTICS, PostgreSQLParserSTACKED, PostgreSQLParserELSIF, PostgreSQLParserREVERSE, PostgreSQLParserSLICE, PostgreSQLParserEXIT, PostgreSQLParserRETURN, PostgreSQLParserQUERY, PostgreSQLParserRAISE, PostgreSQLParserSQLSTATE, PostgreSQLParserDEBUG, PostgreSQLParserLOG, PostgreSQLParserINFO, PostgreSQLParserNOTICE, PostgreSQLParserWARNING, PostgreSQLParserEXCEPTION, PostgreSQLParserASSERT, PostgreSQLParserOPEN, PostgreSQLParserABS, PostgreSQLParserCBRT, PostgreSQLParserCEIL, PostgreSQLParserCEILING, PostgreSQLParserDEGREES, PostgreSQLParserDIV, PostgreSQLParserEXP, PostgreSQLParserFACTORIAL, PostgreSQLParserFLOOR, PostgreSQLParserGCD, PostgreSQLParserLCM, PostgreSQLParserLN, PostgreSQLParserLOG10, PostgreSQLParserMIN_SCALE, PostgreSQLParserMOD, PostgreSQLParserPI, PostgreSQLParserPOWER, PostgreSQLParserRADIANS, PostgreSQLParserROUND, PostgreSQLParserSCALE, PostgreSQLParserSIGN, PostgreSQLParserSQRT, PostgreSQLParserTRIM_SCALE, PostgreSQLParserTRUNC, PostgreSQLParserWIDTH_BUCKET, PostgreSQLParserRANDOM, PostgreSQLParserSETSEED, PostgreSQLParserACOS, PostgreSQLParserACOSD, PostgreSQLParserASIN, PostgreSQLParserASIND, PostgreSQLParserATAN, PostgreSQLParserATAND, PostgreSQLParserATAN2, PostgreSQLParserATAN2D, PostgreSQLParserCOS, PostgreSQLParserCOSD, PostgreSQLParserCOT, PostgreSQLParserCOTD, PostgreSQLParserSIN, PostgreSQLParserSIND, PostgreSQLParserTAN, PostgreSQLParserTAND, PostgreSQLParserSINH, PostgreSQLParserCOSH, PostgreSQLParserTANH, PostgreSQLParserASINH, PostgreSQLParserACOSH, PostgreSQLParserATANH, PostgreSQLParserBIT_LENGTH, PostgreSQLParserCHAR_LENGTH, PostgreSQLParserCHARACTER_LENGTH, PostgreSQLParserLOWER, PostgreSQLParserOCTET_LENGTH, PostgreSQLParserUPPER, PostgreSQLParserASCII, PostgreSQLParserBTRIM, PostgreSQLParserCHR, PostgreSQLParserCONCAT, PostgreSQLParserCONCAT_WS, PostgreSQLParserFORMAT, PostgreSQLParserINITCAP, PostgreSQLParserLENGTH, PostgreSQLParserLPAD, PostgreSQLParserLTRIM, PostgreSQLParserMD5, PostgreSQLParserPARSE_IDENT, PostgreSQLParserPG_CLIENT_ENCODING, PostgreSQLParserQUOTE_IDENT, PostgreSQLParserQUOTE_LITERAL, PostgreSQLParserQUOTE_NULLABLE, PostgreSQLParserREGEXP_COUNT, PostgreSQLParserREGEXP_INSTR, PostgreSQLParserREGEXP_LIKE, PostgreSQLParserREGEXP_MATCH, PostgreSQLParserREGEXP_MATCHES, PostgreSQLParserREGEXP_REPLACE, PostgreSQLParserREGEXP_SPLIT_TO_ARRAY, PostgreSQLParserREGEXP_SPLIT_TO_TABLE, PostgreSQLParserREGEXP_SUBSTR, PostgreSQLParserREPEAT, PostgreSQLParserRPAD, PostgreSQLParserRTRIM, PostgreSQLParserSPLIT_PART, PostgreSQLParserSTARTS_WITH, PostgreSQLParserSTRING_TO_ARRAY, PostgreSQLParserSTRING_TO_TABLE, PostgreSQLParserSTRPOS, PostgreSQLParserSUBSTR, PostgreSQLParserTO_ASCII, PostgreSQLParserTO_HEX, PostgreSQLParserTRANSLATE, PostgreSQLParserUNISTR, PostgreSQLParserAGE, PostgreSQLParserCLOCK_TIMESTAMP, PostgreSQLParserDATE_BIN, PostgreSQLParserDATE_PART, PostgreSQLParserDATE_TRUNC, PostgreSQLParserISFINITE, PostgreSQLParserJUSTIFY_DAYS, PostgreSQLParserJUSTIFY_HOURS, PostgreSQLParserJUSTIFY_INTERVAL, PostgreSQLParserMAKE_DATE, PostgreSQLParserMAKE_INTERVAL, PostgreSQLParserMAKE_TIME, PostgreSQLParserMAKE_TIMESTAMP, PostgreSQLParserMAKE_TIMESTAMPTZ, PostgreSQLParserNOW, PostgreSQLParserSTATEMENT_TIMESTAMP, PostgreSQLParserTIMEOFDAY, PostgreSQLParserTRANSACTION_TIMESTAMP, PostgreSQLParserTO_TIMESTAMP, PostgreSQLParserTO_CHAR, PostgreSQLParserTO_DATE, PostgreSQLParserTO_NUMBER, PostgreSQLParserIdentifier, PostgreSQLParserQuotedIdentifier, PostgreSQLParserUnicodeQuotedIdentifier, PostgreSQLParserPLSQLVARIABLENAME, PostgreSQLParserPLSQLIDENTIFIER:
		p.EnterOuterAlt(localctx, 2)

	default:
		p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// ICopy_delimiterContext is an interface to support dynamic dispatch.
type ICopy_delimiterContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Opt_using() IOpt_usingContext
	DELIMITERS() antlr.TerminalNode
	Sconst() ISconstContext

	// IsCopy_delimiterContext differentiates from other interfaces.
	IsCopy_delimiterContext()
}

type Copy_delimiterContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyCopy_delimiterContext() *Copy_delimiterContext {
	var p = new(Copy_delimiterContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_copy_delimiter
	return p
}

func InitEmptyCopy_delimiterContext(p *Copy_delimiterContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_copy_delimiter
}

func (*Copy_delimiterContext) IsCopy_delimiterContext() {}

func NewCopy_delimiterContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Copy_delimiterContext {
	var p = new(Copy_delimiterContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_copy_delimiter

	return p
}

func (s *Copy_delimiterContext) GetParser() antlr.Parser { return s.parser }

func (s *Copy_delimiterContext) Opt_using() IOpt_usingContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOpt_usingContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOpt_usingContext)
}

func (s *Copy_delimiterContext) DELIMITERS() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserDELIMITERS, 0)
}

func (s *Copy_delimiterContext) Sconst() ISconstContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ISconstContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ISconstContext)
}

func (s *Copy_delimiterContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Copy_delimiterContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Copy_delimiterContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterCopy_delimiter(s)
	}
}

func (s *Copy_delimiterContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitCopy_delimiter(s)
	}
}

func (s *Copy_delimiterContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitCopy_delimiter(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Copy_delimiter() (localctx ICopy_delimiterContext) {
	localctx = NewCopy_delimiterContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 158, PostgreSQLParserRULE_copy_delimiter)
	p.SetState(2713)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetTokenStream().LA(1) {
	case PostgreSQLParserUSING, PostgreSQLParserDELIMITERS:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(2708)
			p.Opt_using()
		}
		{
			p.SetState(2709)
			p.Match(PostgreSQLParserDELIMITERS)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2710)
			p.Sconst()
		}

	case PostgreSQLParserEOF, PostgreSQLParserOPEN_PAREN, PostgreSQLParserSEMI, PostgreSQLParserANALYSE, PostgreSQLParserANALYZE, PostgreSQLParserCREATE, PostgreSQLParserDO, PostgreSQLParserFETCH, PostgreSQLParserGRANT, PostgreSQLParserINTO, PostgreSQLParserNULL_P, PostgreSQLParserSELECT, PostgreSQLParserTABLE, PostgreSQLParserWHERE, PostgreSQLParserWITH, PostgreSQLParserBINARY, PostgreSQLParserFREEZE, PostgreSQLParserABORT_P, PostgreSQLParserALTER, PostgreSQLParserBEGIN_P, PostgreSQLParserCHECKPOINT, PostgreSQLParserCLOSE, PostgreSQLParserCLUSTER, PostgreSQLParserCOMMENT, PostgreSQLParserCOMMIT, PostgreSQLParserCOPY, PostgreSQLParserCSV, PostgreSQLParserDEALLOCATE, PostgreSQLParserDECLARE, PostgreSQLParserDELETE_P, PostgreSQLParserDELIMITER, PostgreSQLParserDISCARD, PostgreSQLParserDROP, PostgreSQLParserENCODING, PostgreSQLParserESCAPE, PostgreSQLParserEXECUTE, PostgreSQLParserEXPLAIN, PostgreSQLParserFORCE, PostgreSQLParserHEADER_P, PostgreSQLParserINSERT, PostgreSQLParserLISTEN, PostgreSQLParserLOAD, PostgreSQLParserLOCK_P, PostgreSQLParserMERGE, PostgreSQLParserMOVE, PostgreSQLParserNOTIFY, PostgreSQLParserPREPARE, PostgreSQLParserQUOTE, PostgreSQLParserREASSIGN, PostgreSQLParserREFRESH, PostgreSQLParserREINDEX, PostgreSQLParserRELEASE, PostgreSQLParserRESET, PostgreSQLParserREVOKE, PostgreSQLParserROLLBACK, PostgreSQLParserSAVEPOINT, PostgreSQLParserSECURITY, PostgreSQLParserSET, PostgreSQLParserSHOW, PostgreSQLParserSTART, PostgreSQLParserTRUNCATE, PostgreSQLParserUNLISTEN, PostgreSQLParserUPDATE, PostgreSQLParserVACUUM, PostgreSQLParserVALUES, PostgreSQLParserCALL, PostgreSQLParserIMPORT_P, PostgreSQLParserEND_P, PostgreSQLParserMetaCommand:
		p.EnterOuterAlt(localctx, 2)

	default:
		p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IOpt_usingContext is an interface to support dynamic dispatch.
type IOpt_usingContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	USING() antlr.TerminalNode

	// IsOpt_usingContext differentiates from other interfaces.
	IsOpt_usingContext()
}

type Opt_usingContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyOpt_usingContext() *Opt_usingContext {
	var p = new(Opt_usingContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opt_using
	return p
}

func InitEmptyOpt_usingContext(p *Opt_usingContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opt_using
}

func (*Opt_usingContext) IsOpt_usingContext() {}

func NewOpt_usingContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_usingContext {
	var p = new(Opt_usingContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_opt_using

	return p
}

func (s *Opt_usingContext) GetParser() antlr.Parser { return s.parser }

func (s *Opt_usingContext) USING() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserUSING, 0)
}

func (s *Opt_usingContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Opt_usingContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Opt_usingContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterOpt_using(s)
	}
}

func (s *Opt_usingContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitOpt_using(s)
	}
}

func (s *Opt_usingContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitOpt_using(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Opt_using() (localctx IOpt_usingContext) {
	localctx = NewOpt_usingContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 160, PostgreSQLParserRULE_opt_using)
	p.SetState(2717)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetTokenStream().LA(1) {
	case PostgreSQLParserUSING:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(2715)
			p.Match(PostgreSQLParserUSING)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case PostgreSQLParserDELIMITERS:
		p.EnterOuterAlt(localctx, 2)

	default:
		p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// ICopy_generic_opt_listContext is an interface to support dynamic dispatch.
type ICopy_generic_opt_listContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	AllCopy_generic_opt_elem() []ICopy_generic_opt_elemContext
	Copy_generic_opt_elem(i int) ICopy_generic_opt_elemContext
	AllCOMMA() []antlr.TerminalNode
	COMMA(i int) antlr.TerminalNode

	// IsCopy_generic_opt_listContext differentiates from other interfaces.
	IsCopy_generic_opt_listContext()
}

type Copy_generic_opt_listContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyCopy_generic_opt_listContext() *Copy_generic_opt_listContext {
	var p = new(Copy_generic_opt_listContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_copy_generic_opt_list
	return p
}

func InitEmptyCopy_generic_opt_listContext(p *Copy_generic_opt_listContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_copy_generic_opt_list
}

func (*Copy_generic_opt_listContext) IsCopy_generic_opt_listContext() {}

func NewCopy_generic_opt_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Copy_generic_opt_listContext {
	var p = new(Copy_generic_opt_listContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_copy_generic_opt_list

	return p
}

func (s *Copy_generic_opt_listContext) GetParser() antlr.Parser { return s.parser }

func (s *Copy_generic_opt_listContext) AllCopy_generic_opt_elem() []ICopy_generic_opt_elemContext {
	children := s.GetChildren()
	len := 0
	for _, ctx := range children {
		if _, ok := ctx.(ICopy_generic_opt_elemContext); ok {
			len++
		}
	}

	tst := make([]ICopy_generic_opt_elemContext, len)
	i := 0
	for _, ctx := range children {
		if t, ok := ctx.(ICopy_generic_opt_elemContext); ok {
			tst[i] = t.(ICopy_generic_opt_elemContext)
			i++
		}
	}

	return tst
}

func (s *Copy_generic_opt_listContext) Copy_generic_opt_elem(i int) ICopy_generic_opt_elemContext {
	var t antlr.RuleContext
	j := 0
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ICopy_generic_opt_elemContext); ok {
			if j == i {
				t = ctx.(antlr.RuleContext)
				break
			}
			j++
		}
	}

	if t == nil {
		return nil
	}

	return t.(ICopy_generic_opt_elemContext)
}

func (s *Copy_generic_opt_listContext) AllCOMMA() []antlr.TerminalNode {
	return s.GetTokens(PostgreSQLParserCOMMA)
}

func (s *Copy_generic_opt_listContext) COMMA(i int) antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCOMMA, i)
}

func (s *Copy_generic_opt_listContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Copy_generic_opt_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Copy_generic_opt_listContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterCopy_generic_opt_list(s)
	}
}

func (s *Copy_generic_opt_listContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitCopy_generic_opt_list(s)
	}
}

func (s *Copy_generic_opt_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitCopy_generic_opt_list(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Copy_generic_opt_list() (localctx ICopy_generic_opt_listContext) {
	localctx = NewCopy_generic_opt_listContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 162, PostgreSQLParserRULE_copy_generic_opt_list)
	var _la int

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(2719)
		p.Copy_generic_opt_elem()
	}
	p.SetState(2724)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}
	_la = p.GetTokenStream().LA(1)

	for _la == PostgreSQLParserCOMMA {
		{
			p.SetState(2720)
			p.Match(PostgreSQLParserCOMMA)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2721)
			p.Copy_generic_opt_elem()
		}

		p.SetState(2726)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}
		_la = p.GetTokenStream().LA(1)
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// ICopy_generic_opt_elemContext is an interface to support dynamic dispatch.
type ICopy_generic_opt_elemContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Collabel() ICollabelContext
	Copy_generic_opt_arg() ICopy_generic_opt_argContext

	// IsCopy_generic_opt_elemContext differentiates from other interfaces.
	IsCopy_generic_opt_elemContext()
}

type Copy_generic_opt_elemContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyCopy_generic_opt_elemContext() *Copy_generic_opt_elemContext {
	var p = new(Copy_generic_opt_elemContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_copy_generic_opt_elem
	return p
}

func InitEmptyCopy_generic_opt_elemContext(p *Copy_generic_opt_elemContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_copy_generic_opt_elem
}

func (*Copy_generic_opt_elemContext) IsCopy_generic_opt_elemContext() {}

func NewCopy_generic_opt_elemContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Copy_generic_opt_elemContext {
	var p = new(Copy_generic_opt_elemContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_copy_generic_opt_elem

	return p
}

func (s *Copy_generic_opt_elemContext) GetParser() antlr.Parser { return s.parser }

func (s *Copy_generic_opt_elemContext) Collabel() ICollabelContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ICollabelContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ICollabelContext)
}

func (s *Copy_generic_opt_elemContext) Copy_generic_opt_arg() ICopy_generic_opt_argContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ICopy_generic_opt_argContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ICopy_generic_opt_argContext)
}

func (s *Copy_generic_opt_elemContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Copy_generic_opt_elemContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Copy_generic_opt_elemContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterCopy_generic_opt_elem(s)
	}
}

func (s *Copy_generic_opt_elemContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitCopy_generic_opt_elem(s)
	}
}

func (s *Copy_generic_opt_elemContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitCopy_generic_opt_elem(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Copy_generic_opt_elem() (localctx ICopy_generic_opt_elemContext) {
	localctx = NewCopy_generic_opt_elemContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 164, PostgreSQLParserRULE_copy_generic_opt_elem)
	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(2727)
		p.Collabel()
	}
	{
		p.SetState(2728)
		p.Copy_generic_opt_arg()
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// ICopy_generic_opt_argContext is an interface to support dynamic dispatch.
type ICopy_generic_opt_argContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Opt_boolean_or_string() IOpt_boolean_or_stringContext
	Numericonly() INumericonlyContext
	STAR() antlr.TerminalNode
	OPEN_PAREN() antlr.TerminalNode
	Copy_generic_opt_arg_list() ICopy_generic_opt_arg_listContext
	CLOSE_PAREN() antlr.TerminalNode

	// IsCopy_generic_opt_argContext differentiates from other interfaces.
	IsCopy_generic_opt_argContext()
}

type Copy_generic_opt_argContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyCopy_generic_opt_argContext() *Copy_generic_opt_argContext {
	var p = new(Copy_generic_opt_argContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_copy_generic_opt_arg
	return p
}

func InitEmptyCopy_generic_opt_argContext(p *Copy_generic_opt_argContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_copy_generic_opt_arg
}

func (*Copy_generic_opt_argContext) IsCopy_generic_opt_argContext() {}

func NewCopy_generic_opt_argContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Copy_generic_opt_argContext {
	var p = new(Copy_generic_opt_argContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_copy_generic_opt_arg

	return p
}

func (s *Copy_generic_opt_argContext) GetParser() antlr.Parser { return s.parser }

func (s *Copy_generic_opt_argContext) Opt_boolean_or_string() IOpt_boolean_or_stringContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOpt_boolean_or_stringContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOpt_boolean_or_stringContext)
}

func (s *Copy_generic_opt_argContext) Numericonly() INumericonlyContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(INumericonlyContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(INumericonlyContext)
}

func (s *Copy_generic_opt_argContext) STAR() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserSTAR, 0)
}

func (s *Copy_generic_opt_argContext) OPEN_PAREN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserOPEN_PAREN, 0)
}

func (s *Copy_generic_opt_argContext) Copy_generic_opt_arg_list() ICopy_generic_opt_arg_listContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ICopy_generic_opt_arg_listContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ICopy_generic_opt_arg_listContext)
}

func (s *Copy_generic_opt_argContext) CLOSE_PAREN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCLOSE_PAREN, 0)
}

func (s *Copy_generic_opt_argContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Copy_generic_opt_argContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Copy_generic_opt_argContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterCopy_generic_opt_arg(s)
	}
}

func (s *Copy_generic_opt_argContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitCopy_generic_opt_arg(s)
	}
}

func (s *Copy_generic_opt_argContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitCopy_generic_opt_arg(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Copy_generic_opt_arg() (localctx ICopy_generic_opt_argContext) {
	localctx = NewCopy_generic_opt_argContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 166, PostgreSQLParserRULE_copy_generic_opt_arg)
	p.SetState(2738)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetTokenStream().LA(1) {
	case PostgreSQLParserAND, PostgreSQLParserARRAY, PostgreSQLParserCOLLATE, PostgreSQLParserCOLUMN, PostgreSQLParserCONSTRAINT, PostgreSQLParserDEFAULT, PostgreSQLParserDO, PostgreSQLParserFALSE_P, PostgreSQLParserFETCH, PostgreSQLParserON, PostgreSQLParserTABLE, PostgreSQLParserTRUE_P, PostgreSQLParserAUTHORIZATION, PostgreSQLParserBINARY, PostgreSQLParserCOLLATION, PostgreSQLParserCONCURRENTLY, PostgreSQLParserCROSS, PostgreSQLParserCURRENT_SCHEMA, PostgreSQLParserFREEZE, PostgreSQLParserFULL, PostgreSQLParserILIKE, PostgreSQLParserINNER_P, PostgreSQLParserIS, PostgreSQLParserISNULL, PostgreSQLParserJOIN, PostgreSQLParserLIKE, PostgreSQLParserNATURAL, PostgreSQLParserNOTNULL, PostgreSQLParserOUTER_P, PostgreSQLParserOVER, PostgreSQLParserOVERLAPS, PostgreSQLParserSIMILAR, PostgreSQLParserVERBOSE, PostgreSQLParserABORT_P, PostgreSQLParserABSOLUTE_P, PostgreSQLParserACCESS, PostgreSQLParserACTION, PostgreSQLParserADD_P, PostgreSQLParserADMIN, PostgreSQLParserAFTER, PostgreSQLParserAGGREGATE, PostgreSQLParserALSO, PostgreSQLParserALTER, PostgreSQLParserALWAYS, PostgreSQLParserASSERTION, PostgreSQLParserASSIGNMENT, PostgreSQLParserAT, PostgreSQLParserATTRIBUTE, PostgreSQLParserBACKWARD, PostgreSQLParserBEFORE, PostgreSQLParserBEGIN_P, PostgreSQLParserBY, PostgreSQLParserCACHE, PostgreSQLParserCALLED, PostgreSQLParserCASCADE, PostgreSQLParserCASCADED, PostgreSQLParserCATALOG, PostgreSQLParserCHAIN, PostgreSQLParserCHARACTERISTICS, PostgreSQLParserCHECKPOINT, PostgreSQLParserCLASS, PostgreSQLParserCLOSE, PostgreSQLParserCLUSTER, PostgreSQLParserCOMMENT, PostgreSQLParserCOMMENTS, PostgreSQLParserCOMMIT, PostgreSQLParserCOMMITTED, PostgreSQLParserCONFIGURATION, PostgreSQLParserCONNECTION, PostgreSQLParserCONSTRAINTS, PostgreSQLParserCONTENT_P, PostgreSQLParserCONTINUE_P, PostgreSQLParserCONVERSION_P, PostgreSQLParserCOPY, PostgreSQLParserCOST, PostgreSQLParserCSV, PostgreSQLParserCURSOR, PostgreSQLParserCYCLE, PostgreSQLParserDATA_P, PostgreSQLParserDATABASE, PostgreSQLParserDAY_P, PostgreSQLParserDEALLOCATE, PostgreSQLParserDECLARE, PostgreSQLParserDEFAULTS, PostgreSQLParserDEFERRED, PostgreSQLParserDEFINER, PostgreSQLParserDELETE_P, PostgreSQLParserDELIMITER, PostgreSQLParserDELIMITERS, PostgreSQLParserDICTIONARY, PostgreSQLParserDISABLE_P, PostgreSQLParserDISCARD, PostgreSQLParserDOCUMENT_P, PostgreSQLParserDOMAIN_P, PostgreSQLParserDOUBLE_P, PostgreSQLParserDROP, PostgreSQLParserEACH, PostgreSQLParserENABLE_P, PostgreSQLParserENCODING, PostgreSQLParserENCRYPTED, PostgreSQLParserENUM_P, PostgreSQLParserESCAPE, PostgreSQLParserEVENT, PostgreSQLParserEXCLUDE, PostgreSQLParserEXCLUDING, PostgreSQLParserEXCLUSIVE, PostgreSQLParserEXECUTE, PostgreSQLParserEXPLAIN, PostgreSQLParserEXTENSION, PostgreSQLParserEXTERNAL, PostgreSQLParserFAMILY, PostgreSQLParserFIRST_P, PostgreSQLParserFOLLOWING, PostgreSQLParserFORCE, PostgreSQLParserFORWARD, PostgreSQLParserFUNCTION, PostgreSQLParserFUNCTIONS, PostgreSQLParserGLOBAL, PostgreSQLParserGRANTED, PostgreSQLParserHANDLER, PostgreSQLParserHEADER_P, PostgreSQLParserHOLD, PostgreSQLParserHOUR_P, PostgreSQLParserIDENTITY_P, PostgreSQLParserIF_P, PostgreSQLParserIMMEDIATE, PostgreSQLParserIMMUTABLE, PostgreSQLParserIMPLICIT_P, PostgreSQLParserINCLUDING, PostgreSQLParserINCREMENT, PostgreSQLParserINDEX, PostgreSQLParserINDEXES, PostgreSQLParserINHERIT, PostgreSQLParserINHERITS, PostgreSQLParserINLINE_P, PostgreSQLParserINSENSITIVE, PostgreSQLParserINSERT, PostgreSQLParserINSTEAD, PostgreSQLParserINVOKER, PostgreSQLParserISOLATION, PostgreSQLParserKEY, PostgreSQLParserLABEL, PostgreSQLParserLANGUAGE, PostgreSQLParserLARGE_P, PostgreSQLParserLAST_P, PostgreSQLParserLEAKPROOF, PostgreSQLParserLEVEL, PostgreSQLParserLISTEN, PostgreSQLParserLOAD, PostgreSQLParserLOCAL, PostgreSQLParserLOCATION, PostgreSQLParserLOCK_P, PostgreSQLParserMAPPING, PostgreSQLParserMATCH, PostgreSQLParserMATERIALIZED, PostgreSQLParserMAXVALUE, PostgreSQLParserMINUTE_P, PostgreSQLParserMINVALUE, PostgreSQLParserMODE, PostgreSQLParserMONTH_P, PostgreSQLParserMOVE, PostgreSQLParserNAME_P, PostgreSQLParserNAMES, PostgreSQLParserNEXT, PostgreSQLParserNO, PostgreSQLParserNOTHING, PostgreSQLParserNOTIFY, PostgreSQLParserNOWAIT, PostgreSQLParserNULLS_P, PostgreSQLParserOBJECT_P, PostgreSQLParserOF, PostgreSQLParserOFF, PostgreSQLParserOIDS, PostgreSQLParserOPERATOR, PostgreSQLParserOPTION, PostgreSQLParserOPTIONS, PostgreSQLParserOWNED, PostgreSQLParserOWNER, PostgreSQLParserPARSER, PostgreSQLParserPARTIAL, PostgreSQLParserPARTITION, PostgreSQLParserPASSING, PostgreSQLParserPASSWORD, PostgreSQLParserPLANS, PostgreSQLParserPRECEDING, PostgreSQLParserPREPARE, PostgreSQLParserPREPARED, PostgreSQLParserPRESERVE, PostgreSQLParserPRIOR, PostgreSQLParserPRIVILEGES, PostgreSQLParserPROCEDURAL, PostgreSQLParserPROCEDURE, PostgreSQLParserPROGRAM, PostgreSQLParserQUOTE, PostgreSQLParserRANGE, PostgreSQLParserREAD, PostgreSQLParserREASSIGN, PostgreSQLParserRECHECK, PostgreSQLParserRECURSIVE, PostgreSQLParserREF, PostgreSQLParserREFRESH, PostgreSQLParserREINDEX, PostgreSQLParserRELATIVE_P, PostgreSQLParserRELEASE, PostgreSQLParserRENAME, PostgreSQLParserREPEATABLE, PostgreSQLParserREPLACE, PostgreSQLParserREPLICA, PostgreSQLParserRESET, PostgreSQLParserRESTART, PostgreSQLParserRESTRICT, PostgreSQLParserRETURNS, PostgreSQLParserREVOKE, PostgreSQLParserROLE, PostgreSQLParserROLLBACK, PostgreSQLParserROWS, PostgreSQLParserRULE, PostgreSQLParserSAVEPOINT, PostgreSQLParserSCHEMA, PostgreSQLParserSCROLL, PostgreSQLParserSEARCH, PostgreSQLParserSECOND_P, PostgreSQLParserSECURITY, PostgreSQLParserSEQUENCE, PostgreSQLParserSEQUENCES, PostgreSQLParserSERIALIZABLE, PostgreSQLParserSERVER, PostgreSQLParserSESSION, PostgreSQLParserSET, PostgreSQLParserSHARE, PostgreSQLParserSHOW, PostgreSQLParserSIMPLE, PostgreSQLParserSNAPSHOT, PostgreSQLParserSTABLE, PostgreSQLParserSTANDALONE_P, PostgreSQLParserSTART, PostgreSQLParserSTATEMENT, PostgreSQLParserSTATISTICS, PostgreSQLParserSTDIN, PostgreSQLParserSTDOUT, PostgreSQLParserSTORAGE, PostgreSQLParserSTRICT_P, PostgreSQLParserSTRIP_P, PostgreSQLParserSYSID, PostgreSQLParserSYSTEM_P, PostgreSQLParserTABLES, PostgreSQLParserTABLESPACE, PostgreSQLParserTEMP, PostgreSQLParserTEMPLATE, PostgreSQLParserTEMPORARY, PostgreSQLParserTEXT_P, PostgreSQLParserTRANSACTION, PostgreSQLParserTRIGGER, PostgreSQLParserTRUNCATE, PostgreSQLParserTRUSTED, PostgreSQLParserTYPE_P, PostgreSQLParserTYPES_P, PostgreSQLParserUNBOUNDED, PostgreSQLParserUNCOMMITTED, PostgreSQLParserUNENCRYPTED, PostgreSQLParserUNKNOWN, PostgreSQLParserUNLISTEN, PostgreSQLParserUNLOGGED, PostgreSQLParserUNTIL, PostgreSQLParserUPDATE, PostgreSQLParserVACUUM, PostgreSQLParserVALID, PostgreSQLParserVALIDATE, PostgreSQLParserVALIDATOR, PostgreSQLParserVARYING, PostgreSQLParserVERSION_P, PostgreSQLParserVIEW, PostgreSQLParserVOLATILE, PostgreSQLParserWHITESPACE_P, PostgreSQLParserWITHOUT, PostgreSQLParserWORK, PostgreSQLParserWRAPPER, PostgreSQLParserWRITE, PostgreSQLParserXML_P, PostgreSQLParserYEAR_P, PostgreSQLParserYES_P, PostgreSQLParserZONE, PostgreSQLParserBETWEEN, PostgreSQLParserBIGINT, PostgreSQLParserBIT, PostgreSQLParserBOOLEAN_P, PostgreSQLParserCHAR_P, PostgreSQLParserCHARACTER, PostgreSQLParserCOALESCE, PostgreSQLParserDEC, PostgreSQLParserDECIMAL_P, PostgreSQLParserEXISTS, PostgreSQLParserEXTRACT, PostgreSQLParserFLOAT_P, PostgreSQLParserGREATEST, PostgreSQLParserINOUT, PostgreSQLParserINT_P, PostgreSQLParserINTEGER, PostgreSQLParserINTERVAL, PostgreSQLParserLEAST, PostgreSQLParserNATIONAL, PostgreSQLParserNCHAR, PostgreSQLParserNONE, PostgreSQLParserNULLIF, PostgreSQLParserNUMERIC, PostgreSQLParserOVERLAY, PostgreSQLParserPOSITION, PostgreSQLParserPRECISION, PostgreSQLParserREAL, PostgreSQLParserROW, PostgreSQLParserSETOF, PostgreSQLParserSMALLINT, PostgreSQLParserSUBSTRING, PostgreSQLParserTIME, PostgreSQLParserTIMESTAMP, PostgreSQLParserTREAT, PostgreSQLParserTRIM, PostgreSQLParserVALUES, PostgreSQLParserVARCHAR, PostgreSQLParserXMLATTRIBUTES, PostgreSQLParserXMLCOMMENT, PostgreSQLParserXMLAGG, PostgreSQLParserXML_IS_WELL_FORMED, PostgreSQLParserXML_IS_WELL_FORMED_DOCUMENT, PostgreSQLParserXML_IS_WELL_FORMED_CONTENT, PostgreSQLParserXPATH, PostgreSQLParserXPATH_EXISTS, PostgreSQLParserXMLCONCAT, PostgreSQLParserXMLELEMENT, PostgreSQLParserXMLEXISTS, PostgreSQLParserXMLFOREST, PostgreSQLParserXMLPARSE, PostgreSQLParserXMLPI, PostgreSQLParserXMLROOT, PostgreSQLParserXMLSERIALIZE, PostgreSQLParserCALL, PostgreSQLParserCURRENT_P, PostgreSQLParserATTACH, PostgreSQLParserDETACH, PostgreSQLParserEXPRESSION, PostgreSQLParserGENERATED, PostgreSQLParserLOGGED, PostgreSQLParserSTORED, PostgreSQLParserINCLUDE, PostgreSQLParserROUTINE, PostgreSQLParserTRANSFORM, PostgreSQLParserIMPORT_P, PostgreSQLParserPOLICY, PostgreSQLParserMETHOD, PostgreSQLParserREFERENCING, PostgreSQLParserNEW, PostgreSQLParserOLD, PostgreSQLParserVALUE_P, PostgreSQLParserSUBSCRIPTION, PostgreSQLParserPUBLICATION, PostgreSQLParserOUT_P, PostgreSQLParserROUTINES, PostgreSQLParserSCHEMAS, PostgreSQLParserPROCEDURES, PostgreSQLParserINPUT_P, PostgreSQLParserSUPPORT, PostgreSQLParserPARALLEL, PostgreSQLParserSQL_P, PostgreSQLParserDEPENDS, PostgreSQLParserOVERRIDING, PostgreSQLParserCONFLICT, PostgreSQLParserSKIP_P, PostgreSQLParserLOCKED, PostgreSQLParserTIES, PostgreSQLParserROLLUP, PostgreSQLParserCUBE, PostgreSQLParserGROUPING, PostgreSQLParserSETS, PostgreSQLParserTABLESAMPLE, PostgreSQLParserORDINALITY, PostgreSQLParserXMLTABLE, PostgreSQLParserCOLUMNS, PostgreSQLParserXMLNAMESPACES, PostgreSQLParserROWTYPE, PostgreSQLParserNORMALIZED, PostgreSQLParserWITHIN, PostgreSQLParserFILTER, PostgreSQLParserGROUPS, PostgreSQLParserOTHERS, PostgreSQLParserNFC, PostgreSQLParserNFD, PostgreSQLParserNFKC, PostgreSQLParserNFKD, PostgreSQLParserUESCAPE, PostgreSQLParserVIEWS, PostgreSQLParserNORMALIZE, PostgreSQLParserDUMP, PostgreSQLParserPRINT_STRICT_PARAMS, PostgreSQLParserVARIABLE_CONFLICT, PostgreSQLParserERROR, PostgreSQLParserUSE_VARIABLE, PostgreSQLParserUSE_COLUMN, PostgreSQLParserALIAS, PostgreSQLParserCONSTANT, PostgreSQLParserPERFORM, PostgreSQLParserGET, PostgreSQLParserDIAGNOSTICS, PostgreSQLParserSTACKED, PostgreSQLParserELSIF, PostgreSQLParserREVERSE, PostgreSQLParserSLICE, PostgreSQLParserEXIT, PostgreSQLParserRETURN, PostgreSQLParserQUERY, PostgreSQLParserRAISE, PostgreSQLParserSQLSTATE, PostgreSQLParserDEBUG, PostgreSQLParserLOG, PostgreSQLParserINFO, PostgreSQLParserNOTICE, PostgreSQLParserWARNING, PostgreSQLParserEXCEPTION, PostgreSQLParserASSERT, PostgreSQLParserOPEN, PostgreSQLParserABS, PostgreSQLParserCBRT, PostgreSQLParserCEIL, PostgreSQLParserCEILING, PostgreSQLParserDEGREES, PostgreSQLParserDIV, PostgreSQLParserEXP, PostgreSQLParserFACTORIAL, PostgreSQLParserFLOOR, PostgreSQLParserGCD, PostgreSQLParserLCM, PostgreSQLParserLN, PostgreSQLParserLOG10, PostgreSQLParserMIN_SCALE, PostgreSQLParserMOD, PostgreSQLParserPI, PostgreSQLParserPOWER, PostgreSQLParserRADIANS, PostgreSQLParserROUND, PostgreSQLParserSCALE, PostgreSQLParserSIGN, PostgreSQLParserSQRT, PostgreSQLParserTRIM_SCALE, PostgreSQLParserTRUNC, PostgreSQLParserWIDTH_BUCKET, PostgreSQLParserRANDOM, PostgreSQLParserSETSEED, PostgreSQLParserACOS, PostgreSQLParserACOSD, PostgreSQLParserASIN, PostgreSQLParserASIND, PostgreSQLParserATAN, PostgreSQLParserATAND, PostgreSQLParserATAN2, PostgreSQLParserATAN2D, PostgreSQLParserCOS, PostgreSQLParserCOSD, PostgreSQLParserCOT, PostgreSQLParserCOTD, PostgreSQLParserSIN, PostgreSQLParserSIND, PostgreSQLParserTAN, PostgreSQLParserTAND, PostgreSQLParserSINH, PostgreSQLParserCOSH, PostgreSQLParserTANH, PostgreSQLParserASINH, PostgreSQLParserACOSH, PostgreSQLParserATANH, PostgreSQLParserBIT_LENGTH, PostgreSQLParserCHAR_LENGTH, PostgreSQLParserCHARACTER_LENGTH, PostgreSQLParserLOWER, PostgreSQLParserOCTET_LENGTH, PostgreSQLParserUPPER, PostgreSQLParserASCII, PostgreSQLParserBTRIM, PostgreSQLParserCHR, PostgreSQLParserCONCAT, PostgreSQLParserCONCAT_WS, PostgreSQLParserFORMAT, PostgreSQLParserINITCAP, PostgreSQLParserLENGTH, PostgreSQLParserLPAD, PostgreSQLParserLTRIM, PostgreSQLParserMD5, PostgreSQLParserPARSE_IDENT, PostgreSQLParserPG_CLIENT_ENCODING, PostgreSQLParserQUOTE_IDENT, PostgreSQLParserQUOTE_LITERAL, PostgreSQLParserQUOTE_NULLABLE, PostgreSQLParserREGEXP_COUNT, PostgreSQLParserREGEXP_INSTR, PostgreSQLParserREGEXP_LIKE, PostgreSQLParserREGEXP_MATCH, PostgreSQLParserREGEXP_MATCHES, PostgreSQLParserREGEXP_REPLACE, PostgreSQLParserREGEXP_SPLIT_TO_ARRAY, PostgreSQLParserREGEXP_SPLIT_TO_TABLE, PostgreSQLParserREGEXP_SUBSTR, PostgreSQLParserREPEAT, PostgreSQLParserRPAD, PostgreSQLParserRTRIM, PostgreSQLParserSPLIT_PART, PostgreSQLParserSTARTS_WITH, PostgreSQLParserSTRING_TO_ARRAY, PostgreSQLParserSTRING_TO_TABLE, PostgreSQLParserSTRPOS, PostgreSQLParserSUBSTR, PostgreSQLParserTO_ASCII, PostgreSQLParserTO_HEX, PostgreSQLParserTRANSLATE, PostgreSQLParserUNISTR, PostgreSQLParserAGE, PostgreSQLParserCLOCK_TIMESTAMP, PostgreSQLParserDATE_BIN, PostgreSQLParserDATE_PART, PostgreSQLParserDATE_TRUNC, PostgreSQLParserISFINITE, PostgreSQLParserJUSTIFY_DAYS, PostgreSQLParserJUSTIFY_HOURS, PostgreSQLParserJUSTIFY_INTERVAL, PostgreSQLParserMAKE_DATE, PostgreSQLParserMAKE_INTERVAL, PostgreSQLParserMAKE_TIME, PostgreSQLParserMAKE_TIMESTAMP, PostgreSQLParserMAKE_TIMESTAMPTZ, PostgreSQLParserNOW, PostgreSQLParserSTATEMENT_TIMESTAMP, PostgreSQLParserTIMEOFDAY, PostgreSQLParserTRANSACTION_TIMESTAMP, PostgreSQLParserTO_TIMESTAMP, PostgreSQLParserTO_CHAR, PostgreSQLParserTO_DATE, PostgreSQLParserTO_NUMBER, PostgreSQLParserIdentifier, PostgreSQLParserQuotedIdentifier, PostgreSQLParserUnicodeQuotedIdentifier, PostgreSQLParserStringConstant, PostgreSQLParserUnicodeEscapeStringConstant, PostgreSQLParserBeginDollarStringConstant, PostgreSQLParserPLSQLVARIABLENAME, PostgreSQLParserPLSQLIDENTIFIER, PostgreSQLParserEscapeStringConstant:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(2730)
			p.Opt_boolean_or_string()
		}

	case PostgreSQLParserPLUS, PostgreSQLParserMINUS, PostgreSQLParserIntegral, PostgreSQLParserNumeric:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(2731)
			p.Numericonly()
		}

	case PostgreSQLParserSTAR:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(2732)
			p.Match(PostgreSQLParserSTAR)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case PostgreSQLParserOPEN_PAREN:
		p.EnterOuterAlt(localctx, 4)
		{
			p.SetState(2733)
			p.Match(PostgreSQLParserOPEN_PAREN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2734)
			p.Copy_generic_opt_arg_list()
		}
		{
			p.SetState(2735)
			p.Match(PostgreSQLParserCLOSE_PAREN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case PostgreSQLParserCLOSE_PAREN, PostgreSQLParserCOMMA:
		p.EnterOuterAlt(localctx, 5)

	default:
		p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// ICopy_generic_opt_arg_listContext is an interface to support dynamic dispatch.
type ICopy_generic_opt_arg_listContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	AllCopy_generic_opt_arg_list_item() []ICopy_generic_opt_arg_list_itemContext
	Copy_generic_opt_arg_list_item(i int) ICopy_generic_opt_arg_list_itemContext
	AllCOMMA() []antlr.TerminalNode
	COMMA(i int) antlr.TerminalNode

	// IsCopy_generic_opt_arg_listContext differentiates from other interfaces.
	IsCopy_generic_opt_arg_listContext()
}

type Copy_generic_opt_arg_listContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyCopy_generic_opt_arg_listContext() *Copy_generic_opt_arg_listContext {
	var p = new(Copy_generic_opt_arg_listContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_copy_generic_opt_arg_list
	return p
}

func InitEmptyCopy_generic_opt_arg_listContext(p *Copy_generic_opt_arg_listContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_copy_generic_opt_arg_list
}

func (*Copy_generic_opt_arg_listContext) IsCopy_generic_opt_arg_listContext() {}

func NewCopy_generic_opt_arg_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Copy_generic_opt_arg_listContext {
	var p = new(Copy_generic_opt_arg_listContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_copy_generic_opt_arg_list

	return p
}

func (s *Copy_generic_opt_arg_listContext) GetParser() antlr.Parser { return s.parser }

func (s *Copy_generic_opt_arg_listContext) AllCopy_generic_opt_arg_list_item() []ICopy_generic_opt_arg_list_itemContext {
	children := s.GetChildren()
	len := 0
	for _, ctx := range children {
		if _, ok := ctx.(ICopy_generic_opt_arg_list_itemContext); ok {
			len++
		}
	}

	tst := make([]ICopy_generic_opt_arg_list_itemContext, len)
	i := 0
	for _, ctx := range children {
		if t, ok := ctx.(ICopy_generic_opt_arg_list_itemContext); ok {
			tst[i] = t.(ICopy_generic_opt_arg_list_itemContext)
			i++
		}
	}

	return tst
}

func (s *Copy_generic_opt_arg_listContext) Copy_generic_opt_arg_list_item(i int) ICopy_generic_opt_arg_list_itemContext {
	var t antlr.RuleContext
	j := 0
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ICopy_generic_opt_arg_list_itemContext); ok {
			if j == i {
				t = ctx.(antlr.RuleContext)
				break
			}
			j++
		}
	}

	if t == nil {
		return nil
	}

	return t.(ICopy_generic_opt_arg_list_itemContext)
}

func (s *Copy_generic_opt_arg_listContext) AllCOMMA() []antlr.TerminalNode {
	return s.GetTokens(PostgreSQLParserCOMMA)
}

func (s *Copy_generic_opt_arg_listContext) COMMA(i int) antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCOMMA, i)
}

func (s *Copy_generic_opt_arg_listContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Copy_generic_opt_arg_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Copy_generic_opt_arg_listContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterCopy_generic_opt_arg_list(s)
	}
}

func (s *Copy_generic_opt_arg_listContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitCopy_generic_opt_arg_list(s)
	}
}

func (s *Copy_generic_opt_arg_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitCopy_generic_opt_arg_list(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Copy_generic_opt_arg_list() (localctx ICopy_generic_opt_arg_listContext) {
	localctx = NewCopy_generic_opt_arg_listContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 168, PostgreSQLParserRULE_copy_generic_opt_arg_list)
	var _la int

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(2740)
		p.Copy_generic_opt_arg_list_item()
	}
	p.SetState(2745)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}
	_la = p.GetTokenStream().LA(1)

	for _la == PostgreSQLParserCOMMA {
		{
			p.SetState(2741)
			p.Match(PostgreSQLParserCOMMA)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2742)
			p.Copy_generic_opt_arg_list_item()
		}

		p.SetState(2747)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}
		_la = p.GetTokenStream().LA(1)
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// ICopy_generic_opt_arg_list_itemContext is an interface to support dynamic dispatch.
type ICopy_generic_opt_arg_list_itemContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Opt_boolean_or_string() IOpt_boolean_or_stringContext

	// IsCopy_generic_opt_arg_list_itemContext differentiates from other interfaces.
	IsCopy_generic_opt_arg_list_itemContext()
}

type Copy_generic_opt_arg_list_itemContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyCopy_generic_opt_arg_list_itemContext() *Copy_generic_opt_arg_list_itemContext {
	var p = new(Copy_generic_opt_arg_list_itemContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_copy_generic_opt_arg_list_item
	return p
}

func InitEmptyCopy_generic_opt_arg_list_itemContext(p *Copy_generic_opt_arg_list_itemContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_copy_generic_opt_arg_list_item
}

func (*Copy_generic_opt_arg_list_itemContext) IsCopy_generic_opt_arg_list_itemContext() {}

func NewCopy_generic_opt_arg_list_itemContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Copy_generic_opt_arg_list_itemContext {
	var p = new(Copy_generic_opt_arg_list_itemContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_copy_generic_opt_arg_list_item

	return p
}

func (s *Copy_generic_opt_arg_list_itemContext) GetParser() antlr.Parser { return s.parser }

func (s *Copy_generic_opt_arg_list_itemContext) Opt_boolean_or_string() IOpt_boolean_or_stringContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOpt_boolean_or_stringContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOpt_boolean_or_stringContext)
}

func (s *Copy_generic_opt_arg_list_itemContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Copy_generic_opt_arg_list_itemContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Copy_generic_opt_arg_list_itemContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterCopy_generic_opt_arg_list_item(s)
	}
}

func (s *Copy_generic_opt_arg_list_itemContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitCopy_generic_opt_arg_list_item(s)
	}
}

func (s *Copy_generic_opt_arg_list_itemContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitCopy_generic_opt_arg_list_item(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Copy_generic_opt_arg_list_item() (localctx ICopy_generic_opt_arg_list_itemContext) {
	localctx = NewCopy_generic_opt_arg_list_itemContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 170, PostgreSQLParserRULE_copy_generic_opt_arg_list_item)
	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(2748)
		p.Opt_boolean_or_string()
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// ICreatestmtContext is an interface to support dynamic dispatch.
type ICreatestmtContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	CREATE() antlr.TerminalNode
	Opttemp() IOpttempContext
	TABLE() antlr.TerminalNode
	AllQualified_name() []IQualified_nameContext
	Qualified_name(i int) IQualified_nameContext
	OPEN_PAREN() antlr.TerminalNode
	Opttableelementlist() IOpttableelementlistContext
	CLOSE_PAREN() antlr.TerminalNode
	Optinherit() IOptinheritContext
	Optpartitionspec() IOptpartitionspecContext
	Table_access_method_clause() ITable_access_method_clauseContext
	Optwith() IOptwithContext
	Oncommitoption() IOncommitoptionContext
	Opttablespace() IOpttablespaceContext
	OF() antlr.TerminalNode
	Any_name() IAny_nameContext
	Opttypedtableelementlist() IOpttypedtableelementlistContext
	PARTITION() antlr.TerminalNode
	Partitionboundspec() IPartitionboundspecContext
	IF_P() antlr.TerminalNode
	NOT() antlr.TerminalNode
	EXISTS() antlr.TerminalNode

	// IsCreatestmtContext differentiates from other interfaces.
	IsCreatestmtContext()
}

type CreatestmtContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyCreatestmtContext() *CreatestmtContext {
	var p = new(CreatestmtContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_createstmt
	return p
}

func InitEmptyCreatestmtContext(p *CreatestmtContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_createstmt
}

func (*CreatestmtContext) IsCreatestmtContext() {}

func NewCreatestmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CreatestmtContext {
	var p = new(CreatestmtContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_createstmt

	return p
}

func (s *CreatestmtContext) GetParser() antlr.Parser { return s.parser }

func (s *CreatestmtContext) CREATE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCREATE, 0)
}

func (s *CreatestmtContext) Opttemp() IOpttempContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOpttempContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOpttempContext)
}

func (s *CreatestmtContext) TABLE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserTABLE, 0)
}

func (s *CreatestmtContext) AllQualified_name() []IQualified_nameContext {
	children := s.GetChildren()
	len := 0
	for _, ctx := range children {
		if _, ok := ctx.(IQualified_nameContext); ok {
			len++
		}
	}

	tst := make([]IQualified_nameContext, len)
	i := 0
	for _, ctx := range children {
		if t, ok := ctx.(IQualified_nameContext); ok {
			tst[i] = t.(IQualified_nameContext)
			i++
		}
	}

	return tst
}

func (s *CreatestmtContext) Qualified_name(i int) IQualified_nameContext {
	var t antlr.RuleContext
	j := 0
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IQualified_nameContext); ok {
			if j == i {
				t = ctx.(antlr.RuleContext)
				break
			}
			j++
		}
	}

	if t == nil {
		return nil
	}

	return t.(IQualified_nameContext)
}

func (s *CreatestmtContext) OPEN_PAREN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserOPEN_PAREN, 0)
}

func (s *CreatestmtContext) Opttableelementlist() IOpttableelementlistContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOpttableelementlistContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOpttableelementlistContext)
}

func (s *CreatestmtContext) CLOSE_PAREN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCLOSE_PAREN, 0)
}

func (s *CreatestmtContext) Optinherit() IOptinheritContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOptinheritContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOptinheritContext)
}

func (s *CreatestmtContext) Optpartitionspec() IOptpartitionspecContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOptpartitionspecContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOptpartitionspecContext)
}

func (s *CreatestmtContext) Table_access_method_clause() ITable_access_method_clauseContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ITable_access_method_clauseContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ITable_access_method_clauseContext)
}

func (s *CreatestmtContext) Optwith() IOptwithContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOptwithContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOptwithContext)
}

func (s *CreatestmtContext) Oncommitoption() IOncommitoptionContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOncommitoptionContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOncommitoptionContext)
}

func (s *CreatestmtContext) Opttablespace() IOpttablespaceContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOpttablespaceContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOpttablespaceContext)
}

func (s *CreatestmtContext) OF() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserOF, 0)
}

func (s *CreatestmtContext) Any_name() IAny_nameContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IAny_nameContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IAny_nameContext)
}

func (s *CreatestmtContext) Opttypedtableelementlist() IOpttypedtableelementlistContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOpttypedtableelementlistContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOpttypedtableelementlistContext)
}

func (s *CreatestmtContext) PARTITION() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserPARTITION, 0)
}

func (s *CreatestmtContext) Partitionboundspec() IPartitionboundspecContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IPartitionboundspecContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IPartitionboundspecContext)
}

func (s *CreatestmtContext) IF_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserIF_P, 0)
}

func (s *CreatestmtContext) NOT() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserNOT, 0)
}

func (s *CreatestmtContext) EXISTS() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserEXISTS, 0)
}

func (s *CreatestmtContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *CreatestmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *CreatestmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterCreatestmt(s)
	}
}

func (s *CreatestmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitCreatestmt(s)
	}
}

func (s *CreatestmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitCreatestmt(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Createstmt() (localctx ICreatestmtContext) {
	localctx = NewCreatestmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 172, PostgreSQLParserRULE_createstmt)
	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(2750)
		p.Match(PostgreSQLParserCREATE)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(2751)
		p.Opttemp()
	}
	{
		p.SetState(2752)
		p.Match(PostgreSQLParserTABLE)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	p.SetState(2756)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 81, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(2753)
			p.Match(PostgreSQLParserIF_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2754)
			p.Match(PostgreSQLParserNOT)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2755)
			p.Match(PostgreSQLParserEXISTS)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	} else if p.HasError() { // JIM
		goto errorExit
	}
	{
		p.SetState(2758)
		p.Qualified_name()
	}
	p.SetState(2789)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetTokenStream().LA(1) {
	case PostgreSQLParserOPEN_PAREN:
		{
			p.SetState(2759)
			p.Match(PostgreSQLParserOPEN_PAREN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2760)
			p.Opttableelementlist()
		}
		{
			p.SetState(2761)
			p.Match(PostgreSQLParserCLOSE_PAREN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2762)
			p.Optinherit()
		}
		{
			p.SetState(2763)
			p.Optpartitionspec()
		}
		{
			p.SetState(2764)
			p.Table_access_method_clause()
		}
		{
			p.SetState(2765)
			p.Optwith()
		}
		{
			p.SetState(2766)
			p.Oncommitoption()
		}
		{
			p.SetState(2767)
			p.Opttablespace()
		}

	case PostgreSQLParserOF:
		{
			p.SetState(2769)
			p.Match(PostgreSQLParserOF)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2770)
			p.Any_name()
		}
		{
			p.SetState(2771)
			p.Opttypedtableelementlist()
		}
		{
			p.SetState(2772)
			p.Optpartitionspec()
		}
		{
			p.SetState(2773)
			p.Table_access_method_clause()
		}
		{
			p.SetState(2774)
			p.Optwith()
		}
		{
			p.SetState(2775)
			p.Oncommitoption()
		}
		{
			p.SetState(2776)
			p.Opttablespace()
		}

	case PostgreSQLParserPARTITION:
		{
			p.SetState(2778)
			p.Match(PostgreSQLParserPARTITION)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2779)
			p.Match(PostgreSQLParserOF)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2780)
			p.Qualified_name()
		}
		{
			p.SetState(2781)
			p.Opttypedtableelementlist()
		}
		{
			p.SetState(2782)
			p.Partitionboundspec()
		}
		{
			p.SetState(2783)
			p.Optpartitionspec()
		}
		{
			p.SetState(2784)
			p.Table_access_method_clause()
		}
		{
			p.SetState(2785)
			p.Optwith()
		}
		{
			p.SetState(2786)
			p.Oncommitoption()
		}
		{
			p.SetState(2787)
			p.Opttablespace()
		}

	default:
		p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IOpttempContext is an interface to support dynamic dispatch.
type IOpttempContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	TEMPORARY() antlr.TerminalNode
	TEMP() antlr.TerminalNode
	LOCAL() antlr.TerminalNode
	GLOBAL() antlr.TerminalNode
	UNLOGGED() antlr.TerminalNode

	// IsOpttempContext differentiates from other interfaces.
	IsOpttempContext()
}

type OpttempContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyOpttempContext() *OpttempContext {
	var p = new(OpttempContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opttemp
	return p
}

func InitEmptyOpttempContext(p *OpttempContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opttemp
}

func (*OpttempContext) IsOpttempContext() {}

func NewOpttempContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *OpttempContext {
	var p = new(OpttempContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_opttemp

	return p
}

func (s *OpttempContext) GetParser() antlr.Parser { return s.parser }

func (s *OpttempContext) TEMPORARY() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserTEMPORARY, 0)
}

func (s *OpttempContext) TEMP() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserTEMP, 0)
}

func (s *OpttempContext) LOCAL() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserLOCAL, 0)
}

func (s *OpttempContext) GLOBAL() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserGLOBAL, 0)
}

func (s *OpttempContext) UNLOGGED() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserUNLOGGED, 0)
}

func (s *OpttempContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *OpttempContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *OpttempContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterOpttemp(s)
	}
}

func (s *OpttempContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitOpttemp(s)
	}
}

func (s *OpttempContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitOpttemp(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Opttemp() (localctx IOpttempContext) {
	localctx = NewOpttempContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 174, PostgreSQLParserRULE_opttemp)
	var _la int

	p.SetState(2799)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetTokenStream().LA(1) {
	case PostgreSQLParserTEMPORARY:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(2791)
			p.Match(PostgreSQLParserTEMPORARY)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case PostgreSQLParserTEMP:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(2792)
			p.Match(PostgreSQLParserTEMP)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case PostgreSQLParserLOCAL:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(2793)
			p.Match(PostgreSQLParserLOCAL)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2794)
			_la = p.GetTokenStream().LA(1)

			if !(_la == PostgreSQLParserTEMP || _la == PostgreSQLParserTEMPORARY) {
				p.GetErrorHandler().RecoverInline(p)
			} else {
				p.GetErrorHandler().ReportMatch(p)
				p.Consume()
			}
		}

	case PostgreSQLParserGLOBAL:
		p.EnterOuterAlt(localctx, 4)
		{
			p.SetState(2795)
			p.Match(PostgreSQLParserGLOBAL)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2796)
			_la = p.GetTokenStream().LA(1)

			if !(_la == PostgreSQLParserTEMP || _la == PostgreSQLParserTEMPORARY) {
				p.GetErrorHandler().RecoverInline(p)
			} else {
				p.GetErrorHandler().ReportMatch(p)
				p.Consume()
			}
		}

	case PostgreSQLParserUNLOGGED:
		p.EnterOuterAlt(localctx, 5)
		{
			p.SetState(2797)
			p.Match(PostgreSQLParserUNLOGGED)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case PostgreSQLParserTABLE, PostgreSQLParserRECURSIVE, PostgreSQLParserSEQUENCE, PostgreSQLParserVIEW:
		p.EnterOuterAlt(localctx, 6)

	default:
		p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IOpttableelementlistContext is an interface to support dynamic dispatch.
type IOpttableelementlistContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Tableelementlist() ITableelementlistContext

	// IsOpttableelementlistContext differentiates from other interfaces.
	IsOpttableelementlistContext()
}

type OpttableelementlistContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyOpttableelementlistContext() *OpttableelementlistContext {
	var p = new(OpttableelementlistContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opttableelementlist
	return p
}

func InitEmptyOpttableelementlistContext(p *OpttableelementlistContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opttableelementlist
}

func (*OpttableelementlistContext) IsOpttableelementlistContext() {}

func NewOpttableelementlistContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *OpttableelementlistContext {
	var p = new(OpttableelementlistContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_opttableelementlist

	return p
}

func (s *OpttableelementlistContext) GetParser() antlr.Parser { return s.parser }

func (s *OpttableelementlistContext) Tableelementlist() ITableelementlistContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ITableelementlistContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ITableelementlistContext)
}

func (s *OpttableelementlistContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *OpttableelementlistContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *OpttableelementlistContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterOpttableelementlist(s)
	}
}

func (s *OpttableelementlistContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitOpttableelementlist(s)
	}
}

func (s *OpttableelementlistContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitOpttableelementlist(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Opttableelementlist() (localctx IOpttableelementlistContext) {
	localctx = NewOpttableelementlistContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 176, PostgreSQLParserRULE_opttableelementlist)
	p.SetState(2803)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetTokenStream().LA(1) {
	case PostgreSQLParserAND, PostgreSQLParserARRAY, PostgreSQLParserCHECK, PostgreSQLParserCOLLATE, PostgreSQLParserCOLUMN, PostgreSQLParserCONSTRAINT, PostgreSQLParserDEFAULT, PostgreSQLParserDO, PostgreSQLParserFETCH, PostgreSQLParserFOREIGN, PostgreSQLParserPRIMARY, PostgreSQLParserTABLE, PostgreSQLParserUNIQUE, PostgreSQLParserIS, PostgreSQLParserLEFT, PostgreSQLParserLIKE, PostgreSQLParserOUTER_P, PostgreSQLParserOVER, PostgreSQLParserRIGHT, PostgreSQLParserABORT_P, PostgreSQLParserABSOLUTE_P, PostgreSQLParserACCESS, PostgreSQLParserACTION, PostgreSQLParserADD_P, PostgreSQLParserADMIN, PostgreSQLParserAFTER, PostgreSQLParserAGGREGATE, PostgreSQLParserALSO, PostgreSQLParserALTER, PostgreSQLParserALWAYS, PostgreSQLParserASSERTION, PostgreSQLParserASSIGNMENT, PostgreSQLParserAT, PostgreSQLParserATTRIBUTE, PostgreSQLParserBACKWARD, PostgreSQLParserBEFORE, PostgreSQLParserBEGIN_P, PostgreSQLParserBY, PostgreSQLParserCACHE, PostgreSQLParserCALLED, PostgreSQLParserCASCADE, PostgreSQLParserCASCADED, PostgreSQLParserCATALOG, PostgreSQLParserCHAIN, PostgreSQLParserCHARACTERISTICS, PostgreSQLParserCHECKPOINT, PostgreSQLParserCLASS, PostgreSQLParserCLOSE, PostgreSQLParserCLUSTER, PostgreSQLParserCOMMENT, PostgreSQLParserCOMMENTS, PostgreSQLParserCOMMIT, PostgreSQLParserCOMMITTED, PostgreSQLParserCONFIGURATION, PostgreSQLParserCONNECTION, PostgreSQLParserCONSTRAINTS, PostgreSQLParserCONTENT_P, PostgreSQLParserCONTINUE_P, PostgreSQLParserCONVERSION_P, PostgreSQLParserCOPY, PostgreSQLParserCOST, PostgreSQLParserCSV, PostgreSQLParserCURSOR, PostgreSQLParserCYCLE, PostgreSQLParserDATA_P, PostgreSQLParserDATABASE, PostgreSQLParserDAY_P, PostgreSQLParserDEALLOCATE, PostgreSQLParserDECLARE, PostgreSQLParserDEFAULTS, PostgreSQLParserDEFERRED, PostgreSQLParserDEFINER, PostgreSQLParserDELETE_P, PostgreSQLParserDELIMITER, PostgreSQLParserDELIMITERS, PostgreSQLParserDICTIONARY, PostgreSQLParserDISABLE_P, PostgreSQLParserDISCARD, PostgreSQLParserDOCUMENT_P, PostgreSQLParserDOMAIN_P, PostgreSQLParserDOUBLE_P, PostgreSQLParserDROP, PostgreSQLParserEACH, PostgreSQLParserENABLE_P, PostgreSQLParserENCODING, PostgreSQLParserENCRYPTED, PostgreSQLParserENUM_P, PostgreSQLParserESCAPE, PostgreSQLParserEVENT, PostgreSQLParserEXCLUDE, PostgreSQLParserEXCLUDING, PostgreSQLParserEXCLUSIVE, PostgreSQLParserEXECUTE, PostgreSQLParserEXPLAIN, PostgreSQLParserEXTENSION, PostgreSQLParserEXTERNAL, PostgreSQLParserFAMILY, PostgreSQLParserFIRST_P, PostgreSQLParserFOLLOWING, PostgreSQLParserFORCE, PostgreSQLParserFORWARD, PostgreSQLParserFUNCTION, PostgreSQLParserFUNCTIONS, PostgreSQLParserGLOBAL, PostgreSQLParserGRANTED, PostgreSQLParserHANDLER, PostgreSQLParserHEADER_P, PostgreSQLParserHOLD, PostgreSQLParserHOUR_P, PostgreSQLParserIDENTITY_P, PostgreSQLParserIF_P, PostgreSQLParserIMMEDIATE, PostgreSQLParserIMMUTABLE, PostgreSQLParserIMPLICIT_P, PostgreSQLParserINCLUDING, PostgreSQLParserINCREMENT, PostgreSQLParserINDEX, PostgreSQLParserINDEXES, PostgreSQLParserINHERIT, PostgreSQLParserINHERITS, PostgreSQLParserINLINE_P, PostgreSQLParserINSENSITIVE, PostgreSQLParserINSERT, PostgreSQLParserINSTEAD, PostgreSQLParserINVOKER, PostgreSQLParserISOLATION, PostgreSQLParserKEY, PostgreSQLParserLABEL, PostgreSQLParserLANGUAGE, PostgreSQLParserLARGE_P, PostgreSQLParserLAST_P, PostgreSQLParserLEAKPROOF, PostgreSQLParserLEVEL, PostgreSQLParserLISTEN, PostgreSQLParserLOAD, PostgreSQLParserLOCAL, PostgreSQLParserLOCATION, PostgreSQLParserLOCK_P, PostgreSQLParserMAPPING, PostgreSQLParserMATCH, PostgreSQLParserMATERIALIZED, PostgreSQLParserMAXVALUE, PostgreSQLParserMINUTE_P, PostgreSQLParserMINVALUE, PostgreSQLParserMODE, PostgreSQLParserMONTH_P, PostgreSQLParserMOVE, PostgreSQLParserNAME_P, PostgreSQLParserNAMES, PostgreSQLParserNEXT, PostgreSQLParserNO, PostgreSQLParserNOTHING, PostgreSQLParserNOTIFY, PostgreSQLParserNOWAIT, PostgreSQLParserNULLS_P, PostgreSQLParserOBJECT_P, PostgreSQLParserOF, PostgreSQLParserOFF, PostgreSQLParserOIDS, PostgreSQLParserOPERATOR, PostgreSQLParserOPTION, PostgreSQLParserOPTIONS, PostgreSQLParserOWNED, PostgreSQLParserOWNER, PostgreSQLParserPARSER, PostgreSQLParserPARTIAL, PostgreSQLParserPARTITION, PostgreSQLParserPASSING, PostgreSQLParserPASSWORD, PostgreSQLParserPLANS, PostgreSQLParserPRECEDING, PostgreSQLParserPREPARE, PostgreSQLParserPREPARED, PostgreSQLParserPRESERVE, PostgreSQLParserPRIOR, PostgreSQLParserPRIVILEGES, PostgreSQLParserPROCEDURAL, PostgreSQLParserPROCEDURE, PostgreSQLParserPROGRAM, PostgreSQLParserQUOTE, PostgreSQLParserRANGE, PostgreSQLParserREAD, PostgreSQLParserREASSIGN, PostgreSQLParserRECHECK, PostgreSQLParserRECURSIVE, PostgreSQLParserREF, PostgreSQLParserREFRESH, PostgreSQLParserREINDEX, PostgreSQLParserRELATIVE_P, PostgreSQLParserRELEASE, PostgreSQLParserRENAME, PostgreSQLParserREPEATABLE, PostgreSQLParserREPLACE, PostgreSQLParserREPLICA, PostgreSQLParserRESET, PostgreSQLParserRESTART, PostgreSQLParserRESTRICT, PostgreSQLParserRETURNS, PostgreSQLParserREVOKE, PostgreSQLParserROLE, PostgreSQLParserROLLBACK, PostgreSQLParserROWS, PostgreSQLParserRULE, PostgreSQLParserSAVEPOINT, PostgreSQLParserSCHEMA, PostgreSQLParserSCROLL, PostgreSQLParserSEARCH, PostgreSQLParserSECOND_P, PostgreSQLParserSECURITY, PostgreSQLParserSEQUENCE, PostgreSQLParserSEQUENCES, PostgreSQLParserSERIALIZABLE, PostgreSQLParserSERVER, PostgreSQLParserSESSION, PostgreSQLParserSET, PostgreSQLParserSHARE, PostgreSQLParserSHOW, PostgreSQLParserSIMPLE, PostgreSQLParserSNAPSHOT, PostgreSQLParserSTABLE, PostgreSQLParserSTANDALONE_P, PostgreSQLParserSTART, PostgreSQLParserSTATEMENT, PostgreSQLParserSTATISTICS, PostgreSQLParserSTDIN, PostgreSQLParserSTDOUT, PostgreSQLParserSTORAGE, PostgreSQLParserSTRICT_P, PostgreSQLParserSTRIP_P, PostgreSQLParserSYSID, PostgreSQLParserSYSTEM_P, PostgreSQLParserTABLES, PostgreSQLParserTABLESPACE, PostgreSQLParserTEMP, PostgreSQLParserTEMPLATE, PostgreSQLParserTEMPORARY, PostgreSQLParserTEXT_P, PostgreSQLParserTRANSACTION, PostgreSQLParserTRIGGER, PostgreSQLParserTRUNCATE, PostgreSQLParserTRUSTED, PostgreSQLParserTYPE_P, PostgreSQLParserTYPES_P, PostgreSQLParserUNBOUNDED, PostgreSQLParserUNCOMMITTED, PostgreSQLParserUNENCRYPTED, PostgreSQLParserUNKNOWN, PostgreSQLParserUNLISTEN, PostgreSQLParserUNLOGGED, PostgreSQLParserUNTIL, PostgreSQLParserUPDATE, PostgreSQLParserVACUUM, PostgreSQLParserVALID, PostgreSQLParserVALIDATE, PostgreSQLParserVALIDATOR, PostgreSQLParserVARYING, PostgreSQLParserVERSION_P, PostgreSQLParserVIEW, PostgreSQLParserVOLATILE, PostgreSQLParserWHITESPACE_P, PostgreSQLParserWITHOUT, PostgreSQLParserWORK, PostgreSQLParserWRAPPER, PostgreSQLParserWRITE, PostgreSQLParserXML_P, PostgreSQLParserYEAR_P, PostgreSQLParserYES_P, PostgreSQLParserZONE, PostgreSQLParserBETWEEN, PostgreSQLParserBIGINT, PostgreSQLParserBIT, PostgreSQLParserBOOLEAN_P, PostgreSQLParserCHAR_P, PostgreSQLParserCHARACTER, PostgreSQLParserCOALESCE, PostgreSQLParserDEC, PostgreSQLParserDECIMAL_P, PostgreSQLParserEXISTS, PostgreSQLParserEXTRACT, PostgreSQLParserFLOAT_P, PostgreSQLParserGREATEST, PostgreSQLParserINOUT, PostgreSQLParserINT_P, PostgreSQLParserINTEGER, PostgreSQLParserINTERVAL, PostgreSQLParserLEAST, PostgreSQLParserNATIONAL, PostgreSQLParserNCHAR, PostgreSQLParserNONE, PostgreSQLParserNULLIF, PostgreSQLParserNUMERIC, PostgreSQLParserOVERLAY, PostgreSQLParserPOSITION, PostgreSQLParserPRECISION, PostgreSQLParserREAL, PostgreSQLParserROW, PostgreSQLParserSETOF, PostgreSQLParserSMALLINT, PostgreSQLParserSUBSTRING, PostgreSQLParserTIME, PostgreSQLParserTIMESTAMP, PostgreSQLParserTREAT, PostgreSQLParserTRIM, PostgreSQLParserVALUES, PostgreSQLParserVARCHAR, PostgreSQLParserXMLATTRIBUTES, PostgreSQLParserXMLCOMMENT, PostgreSQLParserXMLAGG, PostgreSQLParserXML_IS_WELL_FORMED, PostgreSQLParserXML_IS_WELL_FORMED_DOCUMENT, PostgreSQLParserXML_IS_WELL_FORMED_CONTENT, PostgreSQLParserXPATH, PostgreSQLParserXPATH_EXISTS, PostgreSQLParserXMLCONCAT, PostgreSQLParserXMLELEMENT, PostgreSQLParserXMLEXISTS, PostgreSQLParserXMLFOREST, PostgreSQLParserXMLPARSE, PostgreSQLParserXMLPI, PostgreSQLParserXMLROOT, PostgreSQLParserXMLSERIALIZE, PostgreSQLParserCALL, PostgreSQLParserCURRENT_P, PostgreSQLParserATTACH, PostgreSQLParserDETACH, PostgreSQLParserEXPRESSION, PostgreSQLParserGENERATED, PostgreSQLParserLOGGED, PostgreSQLParserSTORED, PostgreSQLParserINCLUDE, PostgreSQLParserROUTINE, PostgreSQLParserTRANSFORM, PostgreSQLParserIMPORT_P, PostgreSQLParserPOLICY, PostgreSQLParserMETHOD, PostgreSQLParserREFERENCING, PostgreSQLParserNEW, PostgreSQLParserOLD, PostgreSQLParserVALUE_P, PostgreSQLParserSUBSCRIPTION, PostgreSQLParserPUBLICATION, PostgreSQLParserOUT_P, PostgreSQLParserROUTINES, PostgreSQLParserSCHEMAS, PostgreSQLParserPROCEDURES, PostgreSQLParserINPUT_P, PostgreSQLParserSUPPORT, PostgreSQLParserPARALLEL, PostgreSQLParserSQL_P, PostgreSQLParserDEPENDS, PostgreSQLParserOVERRIDING, PostgreSQLParserCONFLICT, PostgreSQLParserSKIP_P, PostgreSQLParserLOCKED, PostgreSQLParserTIES, PostgreSQLParserROLLUP, PostgreSQLParserCUBE, PostgreSQLParserGROUPING, PostgreSQLParserSETS, PostgreSQLParserORDINALITY, PostgreSQLParserXMLTABLE, PostgreSQLParserCOLUMNS, PostgreSQLParserXMLNAMESPACES, PostgreSQLParserROWTYPE, PostgreSQLParserNORMALIZED, PostgreSQLParserWITHIN, PostgreSQLParserFILTER, PostgreSQLParserGROUPS, PostgreSQLParserOTHERS, PostgreSQLParserNFC, PostgreSQLParserNFD, PostgreSQLParserNFKC, PostgreSQLParserNFKD, PostgreSQLParserUESCAPE, PostgreSQLParserVIEWS, PostgreSQLParserNORMALIZE, PostgreSQLParserDUMP, PostgreSQLParserPRINT_STRICT_PARAMS, PostgreSQLParserVARIABLE_CONFLICT, PostgreSQLParserERROR, PostgreSQLParserUSE_VARIABLE, PostgreSQLParserUSE_COLUMN, PostgreSQLParserALIAS, PostgreSQLParserCONSTANT, PostgreSQLParserPERFORM, PostgreSQLParserGET, PostgreSQLParserDIAGNOSTICS, PostgreSQLParserSTACKED, PostgreSQLParserELSIF, PostgreSQLParserREVERSE, PostgreSQLParserSLICE, PostgreSQLParserEXIT, PostgreSQLParserRETURN, PostgreSQLParserQUERY, PostgreSQLParserRAISE, PostgreSQLParserSQLSTATE, PostgreSQLParserDEBUG, PostgreSQLParserLOG, PostgreSQLParserINFO, PostgreSQLParserNOTICE, PostgreSQLParserWARNING, PostgreSQLParserEXCEPTION, PostgreSQLParserASSERT, PostgreSQLParserOPEN, PostgreSQLParserABS, PostgreSQLParserCBRT, PostgreSQLParserCEIL, PostgreSQLParserCEILING, PostgreSQLParserDEGREES, PostgreSQLParserDIV, PostgreSQLParserEXP, PostgreSQLParserFACTORIAL, PostgreSQLParserFLOOR, PostgreSQLParserGCD, PostgreSQLParserLCM, PostgreSQLParserLN, PostgreSQLParserLOG10, PostgreSQLParserMIN_SCALE, PostgreSQLParserMOD, PostgreSQLParserPI, PostgreSQLParserPOWER, PostgreSQLParserRADIANS, PostgreSQLParserROUND, PostgreSQLParserSCALE, PostgreSQLParserSIGN, PostgreSQLParserSQRT, PostgreSQLParserTRIM_SCALE, PostgreSQLParserTRUNC, PostgreSQLParserWIDTH_BUCKET, PostgreSQLParserRANDOM, PostgreSQLParserSETSEED, PostgreSQLParserACOS, PostgreSQLParserACOSD, PostgreSQLParserASIN, PostgreSQLParserASIND, PostgreSQLParserATAN, PostgreSQLParserATAND, PostgreSQLParserATAN2, PostgreSQLParserATAN2D, PostgreSQLParserCOS, PostgreSQLParserCOSD, PostgreSQLParserCOT, PostgreSQLParserCOTD, PostgreSQLParserSIN, PostgreSQLParserSIND, PostgreSQLParserTAN, PostgreSQLParserTAND, PostgreSQLParserSINH, PostgreSQLParserCOSH, PostgreSQLParserTANH, PostgreSQLParserASINH, PostgreSQLParserACOSH, PostgreSQLParserATANH, PostgreSQLParserBIT_LENGTH, PostgreSQLParserCHAR_LENGTH, PostgreSQLParserCHARACTER_LENGTH, PostgreSQLParserLOWER, PostgreSQLParserOCTET_LENGTH, PostgreSQLParserUPPER, PostgreSQLParserASCII, PostgreSQLParserBTRIM, PostgreSQLParserCHR, PostgreSQLParserCONCAT, PostgreSQLParserCONCAT_WS, PostgreSQLParserFORMAT, PostgreSQLParserINITCAP, PostgreSQLParserLENGTH, PostgreSQLParserLPAD, PostgreSQLParserLTRIM, PostgreSQLParserMD5, PostgreSQLParserPARSE_IDENT, PostgreSQLParserPG_CLIENT_ENCODING, PostgreSQLParserQUOTE_IDENT, PostgreSQLParserQUOTE_LITERAL, PostgreSQLParserQUOTE_NULLABLE, PostgreSQLParserREGEXP_COUNT, PostgreSQLParserREGEXP_INSTR, PostgreSQLParserREGEXP_LIKE, PostgreSQLParserREGEXP_MATCH, PostgreSQLParserREGEXP_MATCHES, PostgreSQLParserREGEXP_REPLACE, PostgreSQLParserREGEXP_SPLIT_TO_ARRAY, PostgreSQLParserREGEXP_SPLIT_TO_TABLE, PostgreSQLParserREGEXP_SUBSTR, PostgreSQLParserREPEAT, PostgreSQLParserRPAD, PostgreSQLParserRTRIM, PostgreSQLParserSPLIT_PART, PostgreSQLParserSTARTS_WITH, PostgreSQLParserSTRING_TO_ARRAY, PostgreSQLParserSTRING_TO_TABLE, PostgreSQLParserSTRPOS, PostgreSQLParserSUBSTR, PostgreSQLParserTO_ASCII, PostgreSQLParserTO_HEX, PostgreSQLParserTRANSLATE, PostgreSQLParserUNISTR, PostgreSQLParserAGE, PostgreSQLParserCLOCK_TIMESTAMP, PostgreSQLParserDATE_BIN, PostgreSQLParserDATE_PART, PostgreSQLParserDATE_TRUNC, PostgreSQLParserISFINITE, PostgreSQLParserJUSTIFY_DAYS, PostgreSQLParserJUSTIFY_HOURS, PostgreSQLParserJUSTIFY_INTERVAL, PostgreSQLParserMAKE_DATE, PostgreSQLParserMAKE_INTERVAL, PostgreSQLParserMAKE_TIME, PostgreSQLParserMAKE_TIMESTAMP, PostgreSQLParserMAKE_TIMESTAMPTZ, PostgreSQLParserNOW, PostgreSQLParserSTATEMENT_TIMESTAMP, PostgreSQLParserTIMEOFDAY, PostgreSQLParserTRANSACTION_TIMESTAMP, PostgreSQLParserTO_TIMESTAMP, PostgreSQLParserTO_CHAR, PostgreSQLParserTO_DATE, PostgreSQLParserTO_NUMBER, PostgreSQLParserIdentifier, PostgreSQLParserQuotedIdentifier, PostgreSQLParserUnicodeQuotedIdentifier, PostgreSQLParserPLSQLVARIABLENAME, PostgreSQLParserPLSQLIDENTIFIER:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(2801)
			p.Tableelementlist()
		}

	case PostgreSQLParserCLOSE_PAREN:
		p.EnterOuterAlt(localctx, 2)

	default:
		p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IOpttypedtableelementlistContext is an interface to support dynamic dispatch.
type IOpttypedtableelementlistContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	OPEN_PAREN() antlr.TerminalNode
	Typedtableelementlist() ITypedtableelementlistContext
	CLOSE_PAREN() antlr.TerminalNode

	// IsOpttypedtableelementlistContext differentiates from other interfaces.
	IsOpttypedtableelementlistContext()
}

type OpttypedtableelementlistContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyOpttypedtableelementlistContext() *OpttypedtableelementlistContext {
	var p = new(OpttypedtableelementlistContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opttypedtableelementlist
	return p
}

func InitEmptyOpttypedtableelementlistContext(p *OpttypedtableelementlistContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opttypedtableelementlist
}

func (*OpttypedtableelementlistContext) IsOpttypedtableelementlistContext() {}

func NewOpttypedtableelementlistContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *OpttypedtableelementlistContext {
	var p = new(OpttypedtableelementlistContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_opttypedtableelementlist

	return p
}

func (s *OpttypedtableelementlistContext) GetParser() antlr.Parser { return s.parser }

func (s *OpttypedtableelementlistContext) OPEN_PAREN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserOPEN_PAREN, 0)
}

func (s *OpttypedtableelementlistContext) Typedtableelementlist() ITypedtableelementlistContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ITypedtableelementlistContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ITypedtableelementlistContext)
}

func (s *OpttypedtableelementlistContext) CLOSE_PAREN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCLOSE_PAREN, 0)
}

func (s *OpttypedtableelementlistContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *OpttypedtableelementlistContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *OpttypedtableelementlistContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterOpttypedtableelementlist(s)
	}
}

func (s *OpttypedtableelementlistContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitOpttypedtableelementlist(s)
	}
}

func (s *OpttypedtableelementlistContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitOpttypedtableelementlist(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Opttypedtableelementlist() (localctx IOpttypedtableelementlistContext) {
	localctx = NewOpttypedtableelementlistContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 178, PostgreSQLParserRULE_opttypedtableelementlist)
	p.SetState(2810)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 85, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(2805)
			p.Match(PostgreSQLParserOPEN_PAREN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2806)
			p.Typedtableelementlist()
		}
		{
			p.SetState(2807)
			p.Match(PostgreSQLParserCLOSE_PAREN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)

	case antlr.ATNInvalidAltNumber:
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// ITableelementlistContext is an interface to support dynamic dispatch.
type ITableelementlistContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	AllTableelement() []ITableelementContext
	Tableelement(i int) ITableelementContext
	AllCOMMA() []antlr.TerminalNode
	COMMA(i int) antlr.TerminalNode

	// IsTableelementlistContext differentiates from other interfaces.
	IsTableelementlistContext()
}

type TableelementlistContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyTableelementlistContext() *TableelementlistContext {
	var p = new(TableelementlistContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_tableelementlist
	return p
}

func InitEmptyTableelementlistContext(p *TableelementlistContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_tableelementlist
}

func (*TableelementlistContext) IsTableelementlistContext() {}

func NewTableelementlistContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TableelementlistContext {
	var p = new(TableelementlistContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_tableelementlist

	return p
}

func (s *TableelementlistContext) GetParser() antlr.Parser { return s.parser }

func (s *TableelementlistContext) AllTableelement() []ITableelementContext {
	children := s.GetChildren()
	len := 0
	for _, ctx := range children {
		if _, ok := ctx.(ITableelementContext); ok {
			len++
		}
	}

	tst := make([]ITableelementContext, len)
	i := 0
	for _, ctx := range children {
		if t, ok := ctx.(ITableelementContext); ok {
			tst[i] = t.(ITableelementContext)
			i++
		}
	}

	return tst
}

func (s *TableelementlistContext) Tableelement(i int) ITableelementContext {
	var t antlr.RuleContext
	j := 0
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ITableelementContext); ok {
			if j == i {
				t = ctx.(antlr.RuleContext)
				break
			}
			j++
		}
	}

	if t == nil {
		return nil
	}

	return t.(ITableelementContext)
}

func (s *TableelementlistContext) AllCOMMA() []antlr.TerminalNode {
	return s.GetTokens(PostgreSQLParserCOMMA)
}

func (s *TableelementlistContext) COMMA(i int) antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCOMMA, i)
}

func (s *TableelementlistContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *TableelementlistContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *TableelementlistContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterTableelementlist(s)
	}
}

func (s *TableelementlistContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitTableelementlist(s)
	}
}

func (s *TableelementlistContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitTableelementlist(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Tableelementlist() (localctx ITableelementlistContext) {
	localctx = NewTableelementlistContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 180, PostgreSQLParserRULE_tableelementlist)
	var _la int

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(2812)
		p.Tableelement()
	}
	p.SetState(2817)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}
	_la = p.GetTokenStream().LA(1)

	for _la == PostgreSQLParserCOMMA {
		{
			p.SetState(2813)
			p.Match(PostgreSQLParserCOMMA)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2814)
			p.Tableelement()
		}

		p.SetState(2819)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}
		_la = p.GetTokenStream().LA(1)
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// ITypedtableelementlistContext is an interface to support dynamic dispatch.
type ITypedtableelementlistContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	AllTypedtableelement() []ITypedtableelementContext
	Typedtableelement(i int) ITypedtableelementContext
	AllCOMMA() []antlr.TerminalNode
	COMMA(i int) antlr.TerminalNode

	// IsTypedtableelementlistContext differentiates from other interfaces.
	IsTypedtableelementlistContext()
}

type TypedtableelementlistContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyTypedtableelementlistContext() *TypedtableelementlistContext {
	var p = new(TypedtableelementlistContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_typedtableelementlist
	return p
}

func InitEmptyTypedtableelementlistContext(p *TypedtableelementlistContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_typedtableelementlist
}

func (*TypedtableelementlistContext) IsTypedtableelementlistContext() {}

func NewTypedtableelementlistContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TypedtableelementlistContext {
	var p = new(TypedtableelementlistContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_typedtableelementlist

	return p
}

func (s *TypedtableelementlistContext) GetParser() antlr.Parser { return s.parser }

func (s *TypedtableelementlistContext) AllTypedtableelement() []ITypedtableelementContext {
	children := s.GetChildren()
	len := 0
	for _, ctx := range children {
		if _, ok := ctx.(ITypedtableelementContext); ok {
			len++
		}
	}

	tst := make([]ITypedtableelementContext, len)
	i := 0
	for _, ctx := range children {
		if t, ok := ctx.(ITypedtableelementContext); ok {
			tst[i] = t.(ITypedtableelementContext)
			i++
		}
	}

	return tst
}

func (s *TypedtableelementlistContext) Typedtableelement(i int) ITypedtableelementContext {
	var t antlr.RuleContext
	j := 0
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ITypedtableelementContext); ok {
			if j == i {
				t = ctx.(antlr.RuleContext)
				break
			}
			j++
		}
	}

	if t == nil {
		return nil
	}

	return t.(ITypedtableelementContext)
}

func (s *TypedtableelementlistContext) AllCOMMA() []antlr.TerminalNode {
	return s.GetTokens(PostgreSQLParserCOMMA)
}

func (s *TypedtableelementlistContext) COMMA(i int) antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCOMMA, i)
}

func (s *TypedtableelementlistContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *TypedtableelementlistContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *TypedtableelementlistContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterTypedtableelementlist(s)
	}
}

func (s *TypedtableelementlistContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitTypedtableelementlist(s)
	}
}

func (s *TypedtableelementlistContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitTypedtableelementlist(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Typedtableelementlist() (localctx ITypedtableelementlistContext) {
	localctx = NewTypedtableelementlistContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 182, PostgreSQLParserRULE_typedtableelementlist)
	var _la int

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(2820)
		p.Typedtableelement()
	}
	p.SetState(2825)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}
	_la = p.GetTokenStream().LA(1)

	for _la == PostgreSQLParserCOMMA {
		{
			p.SetState(2821)
			p.Match(PostgreSQLParserCOMMA)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2822)
			p.Typedtableelement()
		}

		p.SetState(2827)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}
		_la = p.GetTokenStream().LA(1)
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// ITableelementContext is an interface to support dynamic dispatch.
type ITableelementContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Tableconstraint() ITableconstraintContext
	Tablelikeclause() ITablelikeclauseContext
	ColumnDef() IColumnDefContext

	// IsTableelementContext differentiates from other interfaces.
	IsTableelementContext()
}

type TableelementContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyTableelementContext() *TableelementContext {
	var p = new(TableelementContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_tableelement
	return p
}

func InitEmptyTableelementContext(p *TableelementContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_tableelement
}

func (*TableelementContext) IsTableelementContext() {}

func NewTableelementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TableelementContext {
	var p = new(TableelementContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_tableelement

	return p
}

func (s *TableelementContext) GetParser() antlr.Parser { return s.parser }

func (s *TableelementContext) Tableconstraint() ITableconstraintContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ITableconstraintContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ITableconstraintContext)
}

func (s *TableelementContext) Tablelikeclause() ITablelikeclauseContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ITablelikeclauseContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ITablelikeclauseContext)
}

func (s *TableelementContext) ColumnDef() IColumnDefContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IColumnDefContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IColumnDefContext)
}

func (s *TableelementContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *TableelementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *TableelementContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterTableelement(s)
	}
}

func (s *TableelementContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitTableelement(s)
	}
}

func (s *TableelementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitTableelement(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Tableelement() (localctx ITableelementContext) {
	localctx = NewTableelementContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 184, PostgreSQLParserRULE_tableelement)
	p.SetState(2831)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 88, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(2828)
			p.Tableconstraint()
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(2829)
			p.Tablelikeclause()
		}

	case 3:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(2830)
			p.ColumnDef()
		}

	case antlr.ATNInvalidAltNumber:
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// ITypedtableelementContext is an interface to support dynamic dispatch.
type ITypedtableelementContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	ColumnOptions() IColumnOptionsContext
	Tableconstraint() ITableconstraintContext

	// IsTypedtableelementContext differentiates from other interfaces.
	IsTypedtableelementContext()
}

type TypedtableelementContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyTypedtableelementContext() *TypedtableelementContext {
	var p = new(TypedtableelementContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_typedtableelement
	return p
}

func InitEmptyTypedtableelementContext(p *TypedtableelementContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_typedtableelement
}

func (*TypedtableelementContext) IsTypedtableelementContext() {}

func NewTypedtableelementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TypedtableelementContext {
	var p = new(TypedtableelementContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_typedtableelement

	return p
}

func (s *TypedtableelementContext) GetParser() antlr.Parser { return s.parser }

func (s *TypedtableelementContext) ColumnOptions() IColumnOptionsContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IColumnOptionsContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IColumnOptionsContext)
}

func (s *TypedtableelementContext) Tableconstraint() ITableconstraintContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ITableconstraintContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ITableconstraintContext)
}

func (s *TypedtableelementContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *TypedtableelementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *TypedtableelementContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterTypedtableelement(s)
	}
}

func (s *TypedtableelementContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitTypedtableelement(s)
	}
}

func (s *TypedtableelementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitTypedtableelement(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Typedtableelement() (localctx ITypedtableelementContext) {
	localctx = NewTypedtableelementContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 186, PostgreSQLParserRULE_typedtableelement)
	p.SetState(2835)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 89, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(2833)
			p.ColumnOptions()
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(2834)
			p.Tableconstraint()
		}

	case antlr.ATNInvalidAltNumber:
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IColumnDefContext is an interface to support dynamic dispatch.
type IColumnDefContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Colid() IColidContext
	Typename() ITypenameContext
	Create_generic_options() ICreate_generic_optionsContext
	Colquallist() IColquallistContext

	// IsColumnDefContext differentiates from other interfaces.
	IsColumnDefContext()
}

type ColumnDefContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyColumnDefContext() *ColumnDefContext {
	var p = new(ColumnDefContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_columnDef
	return p
}

func InitEmptyColumnDefContext(p *ColumnDefContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_columnDef
}

func (*ColumnDefContext) IsColumnDefContext() {}

func NewColumnDefContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ColumnDefContext {
	var p = new(ColumnDefContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_columnDef

	return p
}

func (s *ColumnDefContext) GetParser() antlr.Parser { return s.parser }

func (s *ColumnDefContext) Colid() IColidContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IColidContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IColidContext)
}

func (s *ColumnDefContext) Typename() ITypenameContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ITypenameContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ITypenameContext)
}

func (s *ColumnDefContext) Create_generic_options() ICreate_generic_optionsContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ICreate_generic_optionsContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ICreate_generic_optionsContext)
}

func (s *ColumnDefContext) Colquallist() IColquallistContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IColquallistContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IColquallistContext)
}

func (s *ColumnDefContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *ColumnDefContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *ColumnDefContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterColumnDef(s)
	}
}

func (s *ColumnDefContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitColumnDef(s)
	}
}

func (s *ColumnDefContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitColumnDef(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) ColumnDef() (localctx IColumnDefContext) {
	localctx = NewColumnDefContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 188, PostgreSQLParserRULE_columnDef)
	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(2837)
		p.Colid()
	}
	{
		p.SetState(2838)
		p.Typename()
	}
	{
		p.SetState(2839)
		p.Create_generic_options()
	}
	{
		p.SetState(2840)
		p.Colquallist()
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IColumnOptionsContext is an interface to support dynamic dispatch.
type IColumnOptionsContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Colid() IColidContext
	Colquallist() IColquallistContext
	WITH() antlr.TerminalNode
	OPTIONS() antlr.TerminalNode

	// IsColumnOptionsContext differentiates from other interfaces.
	IsColumnOptionsContext()
}

type ColumnOptionsContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyColumnOptionsContext() *ColumnOptionsContext {
	var p = new(ColumnOptionsContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_columnOptions
	return p
}

func InitEmptyColumnOptionsContext(p *ColumnOptionsContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_columnOptions
}

func (*ColumnOptionsContext) IsColumnOptionsContext() {}

func NewColumnOptionsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ColumnOptionsContext {
	var p = new(ColumnOptionsContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_columnOptions

	return p
}

func (s *ColumnOptionsContext) GetParser() antlr.Parser { return s.parser }

func (s *ColumnOptionsContext) Colid() IColidContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IColidContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IColidContext)
}

func (s *ColumnOptionsContext) Colquallist() IColquallistContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IColquallistContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IColquallistContext)
}

func (s *ColumnOptionsContext) WITH() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserWITH, 0)
}

func (s *ColumnOptionsContext) OPTIONS() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserOPTIONS, 0)
}

func (s *ColumnOptionsContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *ColumnOptionsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *ColumnOptionsContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterColumnOptions(s)
	}
}

func (s *ColumnOptionsContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitColumnOptions(s)
	}
}

func (s *ColumnOptionsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitColumnOptions(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) ColumnOptions() (localctx IColumnOptionsContext) {
	localctx = NewColumnOptionsContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 190, PostgreSQLParserRULE_columnOptions)
	var _la int

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(2842)
		p.Colid()
	}
	p.SetState(2845)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}
	_la = p.GetTokenStream().LA(1)

	if _la == PostgreSQLParserWITH {
		{
			p.SetState(2843)
			p.Match(PostgreSQLParserWITH)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2844)
			p.Match(PostgreSQLParserOPTIONS)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	}
	{
		p.SetState(2847)
		p.Colquallist()
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IColquallistContext is an interface to support dynamic dispatch.
type IColquallistContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	AllColconstraint() []IColconstraintContext
	Colconstraint(i int) IColconstraintContext

	// IsColquallistContext differentiates from other interfaces.
	IsColquallistContext()
}

type ColquallistContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyColquallistContext() *ColquallistContext {
	var p = new(ColquallistContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_colquallist
	return p
}

func InitEmptyColquallistContext(p *ColquallistContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_colquallist
}

func (*ColquallistContext) IsColquallistContext() {}

func NewColquallistContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ColquallistContext {
	var p = new(ColquallistContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_colquallist

	return p
}

func (s *ColquallistContext) GetParser() antlr.Parser { return s.parser }

func (s *ColquallistContext) AllColconstraint() []IColconstraintContext {
	children := s.GetChildren()
	len := 0
	for _, ctx := range children {
		if _, ok := ctx.(IColconstraintContext); ok {
			len++
		}
	}

	tst := make([]IColconstraintContext, len)
	i := 0
	for _, ctx := range children {
		if t, ok := ctx.(IColconstraintContext); ok {
			tst[i] = t.(IColconstraintContext)
			i++
		}
	}

	return tst
}

func (s *ColquallistContext) Colconstraint(i int) IColconstraintContext {
	var t antlr.RuleContext
	j := 0
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IColconstraintContext); ok {
			if j == i {
				t = ctx.(antlr.RuleContext)
				break
			}
			j++
		}
	}

	if t == nil {
		return nil
	}

	return t.(IColconstraintContext)
}

func (s *ColquallistContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *ColquallistContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *ColquallistContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterColquallist(s)
	}
}

func (s *ColquallistContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitColquallist(s)
	}
}

func (s *ColquallistContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitColquallist(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Colquallist() (localctx IColquallistContext) {
	localctx = NewColquallistContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 192, PostgreSQLParserRULE_colquallist)
	var _la int

	p.EnterOuterAlt(localctx, 1)
	p.SetState(2852)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}
	_la = p.GetTokenStream().LA(1)

	for ((int64((_la-42)) & ^0x3f) == 0 && ((int64(1)<<(_la-42))&72084085530433547) != 0) || _la == PostgreSQLParserGENERATED {
		{
			p.SetState(2849)
			p.Colconstraint()
		}

		p.SetState(2854)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}
		_la = p.GetTokenStream().LA(1)
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IColconstraintContext is an interface to support dynamic dispatch.
type IColconstraintContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	CONSTRAINT() antlr.TerminalNode
	Name() INameContext
	Colconstraintelem() IColconstraintelemContext
	Constraintattr() IConstraintattrContext
	COLLATE() antlr.TerminalNode
	Any_name() IAny_nameContext

	// IsColconstraintContext differentiates from other interfaces.
	IsColconstraintContext()
}

type ColconstraintContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyColconstraintContext() *ColconstraintContext {
	var p = new(ColconstraintContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_colconstraint
	return p
}

func InitEmptyColconstraintContext(p *ColconstraintContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_colconstraint
}

func (*ColconstraintContext) IsColconstraintContext() {}

func NewColconstraintContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ColconstraintContext {
	var p = new(ColconstraintContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_colconstraint

	return p
}

func (s *ColconstraintContext) GetParser() antlr.Parser { return s.parser }

func (s *ColconstraintContext) CONSTRAINT() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCONSTRAINT, 0)
}

func (s *ColconstraintContext) Name() INameContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(INameContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(INameContext)
}

func (s *ColconstraintContext) Colconstraintelem() IColconstraintelemContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IColconstraintelemContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IColconstraintelemContext)
}

func (s *ColconstraintContext) Constraintattr() IConstraintattrContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IConstraintattrContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IConstraintattrContext)
}

func (s *ColconstraintContext) COLLATE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCOLLATE, 0)
}

func (s *ColconstraintContext) Any_name() IAny_nameContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IAny_nameContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IAny_nameContext)
}

func (s *ColconstraintContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *ColconstraintContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *ColconstraintContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterColconstraint(s)
	}
}

func (s *ColconstraintContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitColconstraint(s)
	}
}

func (s *ColconstraintContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitColconstraint(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Colconstraint() (localctx IColconstraintContext) {
	localctx = NewColconstraintContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 194, PostgreSQLParserRULE_colconstraint)
	p.SetState(2863)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 92, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(2855)
			p.Match(PostgreSQLParserCONSTRAINT)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2856)
			p.Name()
		}
		{
			p.SetState(2857)
			p.Colconstraintelem()
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(2859)
			p.Colconstraintelem()
		}

	case 3:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(2860)
			p.Constraintattr()
		}

	case 4:
		p.EnterOuterAlt(localctx, 4)
		{
			p.SetState(2861)
			p.Match(PostgreSQLParserCOLLATE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2862)
			p.Any_name()
		}

	case antlr.ATNInvalidAltNumber:
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IColconstraintelemContext is an interface to support dynamic dispatch.
type IColconstraintelemContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	NOT() antlr.TerminalNode
	NULL_P() antlr.TerminalNode
	UNIQUE() antlr.TerminalNode
	Opt_definition() IOpt_definitionContext
	Optconstablespace() IOptconstablespaceContext
	PRIMARY() antlr.TerminalNode
	KEY() antlr.TerminalNode
	CHECK() antlr.TerminalNode
	OPEN_PAREN() antlr.TerminalNode
	A_expr() IA_exprContext
	CLOSE_PAREN() antlr.TerminalNode
	Opt_no_inherit() IOpt_no_inheritContext
	DEFAULT() antlr.TerminalNode
	B_expr() IB_exprContext
	GENERATED() antlr.TerminalNode
	Generated_when() IGenerated_whenContext
	AS() antlr.TerminalNode
	IDENTITY_P() antlr.TerminalNode
	Optparenthesizedseqoptlist() IOptparenthesizedseqoptlistContext
	STORED() antlr.TerminalNode
	REFERENCES() antlr.TerminalNode
	Qualified_name() IQualified_nameContext
	Opt_column_list() IOpt_column_listContext
	Key_match() IKey_matchContext
	Key_actions() IKey_actionsContext

	// IsColconstraintelemContext differentiates from other interfaces.
	IsColconstraintelemContext()
}

type ColconstraintelemContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyColconstraintelemContext() *ColconstraintelemContext {
	var p = new(ColconstraintelemContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_colconstraintelem
	return p
}

func InitEmptyColconstraintelemContext(p *ColconstraintelemContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_colconstraintelem
}

func (*ColconstraintelemContext) IsColconstraintelemContext() {}

func NewColconstraintelemContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ColconstraintelemContext {
	var p = new(ColconstraintelemContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_colconstraintelem

	return p
}

func (s *ColconstraintelemContext) GetParser() antlr.Parser { return s.parser }

func (s *ColconstraintelemContext) NOT() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserNOT, 0)
}

func (s *ColconstraintelemContext) NULL_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserNULL_P, 0)
}

func (s *ColconstraintelemContext) UNIQUE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserUNIQUE, 0)
}

func (s *ColconstraintelemContext) Opt_definition() IOpt_definitionContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOpt_definitionContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOpt_definitionContext)
}

func (s *ColconstraintelemContext) Optconstablespace() IOptconstablespaceContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOptconstablespaceContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOptconstablespaceContext)
}

func (s *ColconstraintelemContext) PRIMARY() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserPRIMARY, 0)
}

func (s *ColconstraintelemContext) KEY() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserKEY, 0)
}

func (s *ColconstraintelemContext) CHECK() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCHECK, 0)
}

func (s *ColconstraintelemContext) OPEN_PAREN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserOPEN_PAREN, 0)
}

func (s *ColconstraintelemContext) A_expr() IA_exprContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IA_exprContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IA_exprContext)
}

func (s *ColconstraintelemContext) CLOSE_PAREN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCLOSE_PAREN, 0)
}

func (s *ColconstraintelemContext) Opt_no_inherit() IOpt_no_inheritContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOpt_no_inheritContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOpt_no_inheritContext)
}

func (s *ColconstraintelemContext) DEFAULT() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserDEFAULT, 0)
}

func (s *ColconstraintelemContext) B_expr() IB_exprContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IB_exprContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IB_exprContext)
}

func (s *ColconstraintelemContext) GENERATED() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserGENERATED, 0)
}

func (s *ColconstraintelemContext) Generated_when() IGenerated_whenContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IGenerated_whenContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IGenerated_whenContext)
}

func (s *ColconstraintelemContext) AS() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserAS, 0)
}

func (s *ColconstraintelemContext) IDENTITY_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserIDENTITY_P, 0)
}

func (s *ColconstraintelemContext) Optparenthesizedseqoptlist() IOptparenthesizedseqoptlistContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOptparenthesizedseqoptlistContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOptparenthesizedseqoptlistContext)
}

func (s *ColconstraintelemContext) STORED() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserSTORED, 0)
}

func (s *ColconstraintelemContext) REFERENCES() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserREFERENCES, 0)
}

func (s *ColconstraintelemContext) Qualified_name() IQualified_nameContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IQualified_nameContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IQualified_nameContext)
}

func (s *ColconstraintelemContext) Opt_column_list() IOpt_column_listContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOpt_column_listContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOpt_column_listContext)
}

func (s *ColconstraintelemContext) Key_match() IKey_matchContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IKey_matchContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IKey_matchContext)
}

func (s *ColconstraintelemContext) Key_actions() IKey_actionsContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IKey_actionsContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IKey_actionsContext)
}

func (s *ColconstraintelemContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *ColconstraintelemContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *ColconstraintelemContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterColconstraintelem(s)
	}
}

func (s *ColconstraintelemContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitColconstraintelem(s)
	}
}

func (s *ColconstraintelemContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitColconstraintelem(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Colconstraintelem() (localctx IColconstraintelemContext) {
	localctx = NewColconstraintelemContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 196, PostgreSQLParserRULE_colconstraintelem)
	p.SetState(2903)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetTokenStream().LA(1) {
	case PostgreSQLParserNOT:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(2865)
			p.Match(PostgreSQLParserNOT)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2866)
			p.Match(PostgreSQLParserNULL_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case PostgreSQLParserNULL_P:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(2867)
			p.Match(PostgreSQLParserNULL_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case PostgreSQLParserUNIQUE:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(2868)
			p.Match(PostgreSQLParserUNIQUE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2869)
			p.Opt_definition()
		}
		{
			p.SetState(2870)
			p.Optconstablespace()
		}

	case PostgreSQLParserPRIMARY:
		p.EnterOuterAlt(localctx, 4)
		{
			p.SetState(2872)
			p.Match(PostgreSQLParserPRIMARY)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2873)
			p.Match(PostgreSQLParserKEY)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2874)
			p.Opt_definition()
		}
		{
			p.SetState(2875)
			p.Optconstablespace()
		}

	case PostgreSQLParserCHECK:
		p.EnterOuterAlt(localctx, 5)
		{
			p.SetState(2877)
			p.Match(PostgreSQLParserCHECK)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2878)
			p.Match(PostgreSQLParserOPEN_PAREN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2879)
			p.A_expr()
		}
		{
			p.SetState(2880)
			p.Match(PostgreSQLParserCLOSE_PAREN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2881)
			p.Opt_no_inherit()
		}

	case PostgreSQLParserDEFAULT:
		p.EnterOuterAlt(localctx, 6)
		{
			p.SetState(2883)
			p.Match(PostgreSQLParserDEFAULT)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2884)
			p.b_expr(0)
		}

	case PostgreSQLParserGENERATED:
		p.EnterOuterAlt(localctx, 7)
		{
			p.SetState(2885)
			p.Match(PostgreSQLParserGENERATED)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2886)
			p.Generated_when()
		}
		{
			p.SetState(2887)
			p.Match(PostgreSQLParserAS)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		p.SetState(2895)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}

		switch p.GetTokenStream().LA(1) {
		case PostgreSQLParserIDENTITY_P:
			{
				p.SetState(2888)
				p.Match(PostgreSQLParserIDENTITY_P)
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}
			{
				p.SetState(2889)
				p.Optparenthesizedseqoptlist()
			}

		case PostgreSQLParserOPEN_PAREN:
			{
				p.SetState(2890)
				p.Match(PostgreSQLParserOPEN_PAREN)
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}
			{
				p.SetState(2891)
				p.A_expr()
			}
			{
				p.SetState(2892)
				p.Match(PostgreSQLParserCLOSE_PAREN)
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}
			{
				p.SetState(2893)
				p.Match(PostgreSQLParserSTORED)
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}

		default:
			p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
			goto errorExit
		}

	case PostgreSQLParserREFERENCES:
		p.EnterOuterAlt(localctx, 8)
		{
			p.SetState(2897)
			p.Match(PostgreSQLParserREFERENCES)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2898)
			p.Qualified_name()
		}
		{
			p.SetState(2899)
			p.Opt_column_list()
		}
		{
			p.SetState(2900)
			p.Key_match()
		}
		{
			p.SetState(2901)
			p.Key_actions()
		}

	default:
		p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IGenerated_whenContext is an interface to support dynamic dispatch.
type IGenerated_whenContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	ALWAYS() antlr.TerminalNode
	BY() antlr.TerminalNode
	DEFAULT() antlr.TerminalNode

	// IsGenerated_whenContext differentiates from other interfaces.
	IsGenerated_whenContext()
}

type Generated_whenContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyGenerated_whenContext() *Generated_whenContext {
	var p = new(Generated_whenContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_generated_when
	return p
}

func InitEmptyGenerated_whenContext(p *Generated_whenContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_generated_when
}

func (*Generated_whenContext) IsGenerated_whenContext() {}

func NewGenerated_whenContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Generated_whenContext {
	var p = new(Generated_whenContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_generated_when

	return p
}

func (s *Generated_whenContext) GetParser() antlr.Parser { return s.parser }

func (s *Generated_whenContext) ALWAYS() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserALWAYS, 0)
}

func (s *Generated_whenContext) BY() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserBY, 0)
}

func (s *Generated_whenContext) DEFAULT() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserDEFAULT, 0)
}

func (s *Generated_whenContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Generated_whenContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Generated_whenContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterGenerated_when(s)
	}
}

func (s *Generated_whenContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitGenerated_when(s)
	}
}

func (s *Generated_whenContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitGenerated_when(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Generated_when() (localctx IGenerated_whenContext) {
	localctx = NewGenerated_whenContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 198, PostgreSQLParserRULE_generated_when)
	p.SetState(2908)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetTokenStream().LA(1) {
	case PostgreSQLParserALWAYS:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(2905)
			p.Match(PostgreSQLParserALWAYS)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case PostgreSQLParserBY:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(2906)
			p.Match(PostgreSQLParserBY)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2907)
			p.Match(PostgreSQLParserDEFAULT)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	default:
		p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IConstraintattrContext is an interface to support dynamic dispatch.
type IConstraintattrContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	DEFERRABLE() antlr.TerminalNode
	NOT() antlr.TerminalNode
	INITIALLY() antlr.TerminalNode
	DEFERRED() antlr.TerminalNode
	IMMEDIATE() antlr.TerminalNode

	// IsConstraintattrContext differentiates from other interfaces.
	IsConstraintattrContext()
}

type ConstraintattrContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyConstraintattrContext() *ConstraintattrContext {
	var p = new(ConstraintattrContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_constraintattr
	return p
}

func InitEmptyConstraintattrContext(p *ConstraintattrContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_constraintattr
}

func (*ConstraintattrContext) IsConstraintattrContext() {}

func NewConstraintattrContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ConstraintattrContext {
	var p = new(ConstraintattrContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_constraintattr

	return p
}

func (s *ConstraintattrContext) GetParser() antlr.Parser { return s.parser }

func (s *ConstraintattrContext) DEFERRABLE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserDEFERRABLE, 0)
}

func (s *ConstraintattrContext) NOT() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserNOT, 0)
}

func (s *ConstraintattrContext) INITIALLY() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserINITIALLY, 0)
}

func (s *ConstraintattrContext) DEFERRED() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserDEFERRED, 0)
}

func (s *ConstraintattrContext) IMMEDIATE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserIMMEDIATE, 0)
}

func (s *ConstraintattrContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *ConstraintattrContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *ConstraintattrContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterConstraintattr(s)
	}
}

func (s *ConstraintattrContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitConstraintattr(s)
	}
}

func (s *ConstraintattrContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitConstraintattr(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Constraintattr() (localctx IConstraintattrContext) {
	localctx = NewConstraintattrContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 200, PostgreSQLParserRULE_constraintattr)
	var _la int

	p.SetState(2915)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetTokenStream().LA(1) {
	case PostgreSQLParserDEFERRABLE:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(2910)
			p.Match(PostgreSQLParserDEFERRABLE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case PostgreSQLParserNOT:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(2911)
			p.Match(PostgreSQLParserNOT)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2912)
			p.Match(PostgreSQLParserDEFERRABLE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case PostgreSQLParserINITIALLY:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(2913)
			p.Match(PostgreSQLParserINITIALLY)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2914)
			_la = p.GetTokenStream().LA(1)

			if !(_la == PostgreSQLParserDEFERRED || _la == PostgreSQLParserIMMEDIATE) {
				p.GetErrorHandler().RecoverInline(p)
			} else {
				p.GetErrorHandler().ReportMatch(p)
				p.Consume()
			}
		}

	default:
		p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// ITablelikeclauseContext is an interface to support dynamic dispatch.
type ITablelikeclauseContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	LIKE() antlr.TerminalNode
	Qualified_name() IQualified_nameContext
	Tablelikeoptionlist() ITablelikeoptionlistContext

	// IsTablelikeclauseContext differentiates from other interfaces.
	IsTablelikeclauseContext()
}

type TablelikeclauseContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyTablelikeclauseContext() *TablelikeclauseContext {
	var p = new(TablelikeclauseContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_tablelikeclause
	return p
}

func InitEmptyTablelikeclauseContext(p *TablelikeclauseContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_tablelikeclause
}

func (*TablelikeclauseContext) IsTablelikeclauseContext() {}

func NewTablelikeclauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TablelikeclauseContext {
	var p = new(TablelikeclauseContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_tablelikeclause

	return p
}

func (s *TablelikeclauseContext) GetParser() antlr.Parser { return s.parser }

func (s *TablelikeclauseContext) LIKE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserLIKE, 0)
}

func (s *TablelikeclauseContext) Qualified_name() IQualified_nameContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IQualified_nameContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IQualified_nameContext)
}

func (s *TablelikeclauseContext) Tablelikeoptionlist() ITablelikeoptionlistContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ITablelikeoptionlistContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ITablelikeoptionlistContext)
}

func (s *TablelikeclauseContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *TablelikeclauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *TablelikeclauseContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterTablelikeclause(s)
	}
}

func (s *TablelikeclauseContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitTablelikeclause(s)
	}
}

func (s *TablelikeclauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitTablelikeclause(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Tablelikeclause() (localctx ITablelikeclauseContext) {
	localctx = NewTablelikeclauseContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 202, PostgreSQLParserRULE_tablelikeclause)
	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(2917)
		p.Match(PostgreSQLParserLIKE)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(2918)
		p.Qualified_name()
	}
	{
		p.SetState(2919)
		p.Tablelikeoptionlist()
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// ITablelikeoptionlistContext is an interface to support dynamic dispatch.
type ITablelikeoptionlistContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	AllTablelikeoption() []ITablelikeoptionContext
	Tablelikeoption(i int) ITablelikeoptionContext
	AllINCLUDING() []antlr.TerminalNode
	INCLUDING(i int) antlr.TerminalNode
	AllEXCLUDING() []antlr.TerminalNode
	EXCLUDING(i int) antlr.TerminalNode

	// IsTablelikeoptionlistContext differentiates from other interfaces.
	IsTablelikeoptionlistContext()
}

type TablelikeoptionlistContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyTablelikeoptionlistContext() *TablelikeoptionlistContext {
	var p = new(TablelikeoptionlistContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_tablelikeoptionlist
	return p
}

func InitEmptyTablelikeoptionlistContext(p *TablelikeoptionlistContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_tablelikeoptionlist
}

func (*TablelikeoptionlistContext) IsTablelikeoptionlistContext() {}

func NewTablelikeoptionlistContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TablelikeoptionlistContext {
	var p = new(TablelikeoptionlistContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_tablelikeoptionlist

	return p
}

func (s *TablelikeoptionlistContext) GetParser() antlr.Parser { return s.parser }

func (s *TablelikeoptionlistContext) AllTablelikeoption() []ITablelikeoptionContext {
	children := s.GetChildren()
	len := 0
	for _, ctx := range children {
		if _, ok := ctx.(ITablelikeoptionContext); ok {
			len++
		}
	}

	tst := make([]ITablelikeoptionContext, len)
	i := 0
	for _, ctx := range children {
		if t, ok := ctx.(ITablelikeoptionContext); ok {
			tst[i] = t.(ITablelikeoptionContext)
			i++
		}
	}

	return tst
}

func (s *TablelikeoptionlistContext) Tablelikeoption(i int) ITablelikeoptionContext {
	var t antlr.RuleContext
	j := 0
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ITablelikeoptionContext); ok {
			if j == i {
				t = ctx.(antlr.RuleContext)
				break
			}
			j++
		}
	}

	if t == nil {
		return nil
	}

	return t.(ITablelikeoptionContext)
}

func (s *TablelikeoptionlistContext) AllINCLUDING() []antlr.TerminalNode {
	return s.GetTokens(PostgreSQLParserINCLUDING)
}

func (s *TablelikeoptionlistContext) INCLUDING(i int) antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserINCLUDING, i)
}

func (s *TablelikeoptionlistContext) AllEXCLUDING() []antlr.TerminalNode {
	return s.GetTokens(PostgreSQLParserEXCLUDING)
}

func (s *TablelikeoptionlistContext) EXCLUDING(i int) antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserEXCLUDING, i)
}

func (s *TablelikeoptionlistContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *TablelikeoptionlistContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *TablelikeoptionlistContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterTablelikeoptionlist(s)
	}
}

func (s *TablelikeoptionlistContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitTablelikeoptionlist(s)
	}
}

func (s *TablelikeoptionlistContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitTablelikeoptionlist(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Tablelikeoptionlist() (localctx ITablelikeoptionlistContext) {
	localctx = NewTablelikeoptionlistContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 204, PostgreSQLParserRULE_tablelikeoptionlist)
	var _la int

	p.EnterOuterAlt(localctx, 1)
	p.SetState(2925)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}
	_la = p.GetTokenStream().LA(1)

	for _la == PostgreSQLParserEXCLUDING || _la == PostgreSQLParserINCLUDING {
		{
			p.SetState(2921)
			_la = p.GetTokenStream().LA(1)

			if !(_la == PostgreSQLParserEXCLUDING || _la == PostgreSQLParserINCLUDING) {
				p.GetErrorHandler().RecoverInline(p)
			} else {
				p.GetErrorHandler().ReportMatch(p)
				p.Consume()
			}
		}
		{
			p.SetState(2922)
			p.Tablelikeoption()
		}

		p.SetState(2927)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}
		_la = p.GetTokenStream().LA(1)
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// ITablelikeoptionContext is an interface to support dynamic dispatch.
type ITablelikeoptionContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	COMMENTS() antlr.TerminalNode
	CONSTRAINTS() antlr.TerminalNode
	DEFAULTS() antlr.TerminalNode
	IDENTITY_P() antlr.TerminalNode
	GENERATED() antlr.TerminalNode
	INDEXES() antlr.TerminalNode
	STATISTICS() antlr.TerminalNode
	STORAGE() antlr.TerminalNode
	ALL() antlr.TerminalNode

	// IsTablelikeoptionContext differentiates from other interfaces.
	IsTablelikeoptionContext()
}

type TablelikeoptionContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyTablelikeoptionContext() *TablelikeoptionContext {
	var p = new(TablelikeoptionContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_tablelikeoption
	return p
}

func InitEmptyTablelikeoptionContext(p *TablelikeoptionContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_tablelikeoption
}

func (*TablelikeoptionContext) IsTablelikeoptionContext() {}

func NewTablelikeoptionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TablelikeoptionContext {
	var p = new(TablelikeoptionContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_tablelikeoption

	return p
}

func (s *TablelikeoptionContext) GetParser() antlr.Parser { return s.parser }

func (s *TablelikeoptionContext) COMMENTS() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCOMMENTS, 0)
}

func (s *TablelikeoptionContext) CONSTRAINTS() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCONSTRAINTS, 0)
}

func (s *TablelikeoptionContext) DEFAULTS() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserDEFAULTS, 0)
}

func (s *TablelikeoptionContext) IDENTITY_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserIDENTITY_P, 0)
}

func (s *TablelikeoptionContext) GENERATED() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserGENERATED, 0)
}

func (s *TablelikeoptionContext) INDEXES() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserINDEXES, 0)
}

func (s *TablelikeoptionContext) STATISTICS() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserSTATISTICS, 0)
}

func (s *TablelikeoptionContext) STORAGE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserSTORAGE, 0)
}

func (s *TablelikeoptionContext) ALL() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserALL, 0)
}

func (s *TablelikeoptionContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *TablelikeoptionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *TablelikeoptionContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterTablelikeoption(s)
	}
}

func (s *TablelikeoptionContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitTablelikeoption(s)
	}
}

func (s *TablelikeoptionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitTablelikeoption(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Tablelikeoption() (localctx ITablelikeoptionContext) {
	localctx = NewTablelikeoptionContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 206, PostgreSQLParserRULE_tablelikeoption)
	var _la int

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(2928)
		_la = p.GetTokenStream().LA(1)

		if !(_la == PostgreSQLParserALL || ((int64((_la-160)) & ^0x3f) == 0 && ((int64(1)<<(_la-160))&576460752303947809) != 0) || _la == PostgreSQLParserINDEXES || _la == PostgreSQLParserSTATISTICS || _la == PostgreSQLParserSTORAGE || _la == PostgreSQLParserGENERATED) {
			p.GetErrorHandler().RecoverInline(p)
		} else {
			p.GetErrorHandler().ReportMatch(p)
			p.Consume()
		}
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// ITableconstraintContext is an interface to support dynamic dispatch.
type ITableconstraintContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	CONSTRAINT() antlr.TerminalNode
	Name() INameContext
	Constraintelem() IConstraintelemContext

	// IsTableconstraintContext differentiates from other interfaces.
	IsTableconstraintContext()
}

type TableconstraintContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyTableconstraintContext() *TableconstraintContext {
	var p = new(TableconstraintContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_tableconstraint
	return p
}

func InitEmptyTableconstraintContext(p *TableconstraintContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_tableconstraint
}

func (*TableconstraintContext) IsTableconstraintContext() {}

func NewTableconstraintContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TableconstraintContext {
	var p = new(TableconstraintContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_tableconstraint

	return p
}

func (s *TableconstraintContext) GetParser() antlr.Parser { return s.parser }

func (s *TableconstraintContext) CONSTRAINT() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCONSTRAINT, 0)
}

func (s *TableconstraintContext) Name() INameContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(INameContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(INameContext)
}

func (s *TableconstraintContext) Constraintelem() IConstraintelemContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IConstraintelemContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IConstraintelemContext)
}

func (s *TableconstraintContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *TableconstraintContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *TableconstraintContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterTableconstraint(s)
	}
}

func (s *TableconstraintContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitTableconstraint(s)
	}
}

func (s *TableconstraintContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitTableconstraint(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Tableconstraint() (localctx ITableconstraintContext) {
	localctx = NewTableconstraintContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 208, PostgreSQLParserRULE_tableconstraint)
	p.SetState(2935)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetTokenStream().LA(1) {
	case PostgreSQLParserCONSTRAINT:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(2930)
			p.Match(PostgreSQLParserCONSTRAINT)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2931)
			p.Name()
		}
		{
			p.SetState(2932)
			p.Constraintelem()
		}

	case PostgreSQLParserCHECK, PostgreSQLParserFOREIGN, PostgreSQLParserPRIMARY, PostgreSQLParserUNIQUE, PostgreSQLParserEXCLUDE:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(2934)
			p.Constraintelem()
		}

	default:
		p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IConstraintelemContext is an interface to support dynamic dispatch.
type IConstraintelemContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	CHECK() antlr.TerminalNode
	OPEN_PAREN() antlr.TerminalNode
	A_expr() IA_exprContext
	CLOSE_PAREN() antlr.TerminalNode
	Constraintattributespec() IConstraintattributespecContext
	UNIQUE() antlr.TerminalNode
	Columnlist() IColumnlistContext
	Opt_c_include() IOpt_c_includeContext
	Opt_definition() IOpt_definitionContext
	Optconstablespace() IOptconstablespaceContext
	Existingindex() IExistingindexContext
	PRIMARY() antlr.TerminalNode
	KEY() antlr.TerminalNode
	EXCLUDE() antlr.TerminalNode
	Access_method_clause() IAccess_method_clauseContext
	Exclusionconstraintlist() IExclusionconstraintlistContext
	Exclusionwhereclause() IExclusionwhereclauseContext
	FOREIGN() antlr.TerminalNode
	REFERENCES() antlr.TerminalNode
	Qualified_name() IQualified_nameContext
	Opt_column_list() IOpt_column_listContext
	Key_match() IKey_matchContext
	Key_actions() IKey_actionsContext

	// IsConstraintelemContext differentiates from other interfaces.
	IsConstraintelemContext()
}

type ConstraintelemContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyConstraintelemContext() *ConstraintelemContext {
	var p = new(ConstraintelemContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_constraintelem
	return p
}

func InitEmptyConstraintelemContext(p *ConstraintelemContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_constraintelem
}

func (*ConstraintelemContext) IsConstraintelemContext() {}

func NewConstraintelemContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ConstraintelemContext {
	var p = new(ConstraintelemContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_constraintelem

	return p
}

func (s *ConstraintelemContext) GetParser() antlr.Parser { return s.parser }

func (s *ConstraintelemContext) CHECK() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCHECK, 0)
}

func (s *ConstraintelemContext) OPEN_PAREN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserOPEN_PAREN, 0)
}

func (s *ConstraintelemContext) A_expr() IA_exprContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IA_exprContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IA_exprContext)
}

func (s *ConstraintelemContext) CLOSE_PAREN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCLOSE_PAREN, 0)
}

func (s *ConstraintelemContext) Constraintattributespec() IConstraintattributespecContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IConstraintattributespecContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IConstraintattributespecContext)
}

func (s *ConstraintelemContext) UNIQUE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserUNIQUE, 0)
}

func (s *ConstraintelemContext) Columnlist() IColumnlistContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IColumnlistContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IColumnlistContext)
}

func (s *ConstraintelemContext) Opt_c_include() IOpt_c_includeContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOpt_c_includeContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOpt_c_includeContext)
}

func (s *ConstraintelemContext) Opt_definition() IOpt_definitionContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOpt_definitionContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOpt_definitionContext)
}

func (s *ConstraintelemContext) Optconstablespace() IOptconstablespaceContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOptconstablespaceContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOptconstablespaceContext)
}

func (s *ConstraintelemContext) Existingindex() IExistingindexContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IExistingindexContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IExistingindexContext)
}

func (s *ConstraintelemContext) PRIMARY() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserPRIMARY, 0)
}

func (s *ConstraintelemContext) KEY() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserKEY, 0)
}

func (s *ConstraintelemContext) EXCLUDE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserEXCLUDE, 0)
}

func (s *ConstraintelemContext) Access_method_clause() IAccess_method_clauseContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IAccess_method_clauseContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IAccess_method_clauseContext)
}

func (s *ConstraintelemContext) Exclusionconstraintlist() IExclusionconstraintlistContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IExclusionconstraintlistContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IExclusionconstraintlistContext)
}

func (s *ConstraintelemContext) Exclusionwhereclause() IExclusionwhereclauseContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IExclusionwhereclauseContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IExclusionwhereclauseContext)
}

func (s *ConstraintelemContext) FOREIGN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserFOREIGN, 0)
}

func (s *ConstraintelemContext) REFERENCES() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserREFERENCES, 0)
}

func (s *ConstraintelemContext) Qualified_name() IQualified_nameContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IQualified_nameContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IQualified_nameContext)
}

func (s *ConstraintelemContext) Opt_column_list() IOpt_column_listContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOpt_column_listContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOpt_column_listContext)
}

func (s *ConstraintelemContext) Key_match() IKey_matchContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IKey_matchContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IKey_matchContext)
}

func (s *ConstraintelemContext) Key_actions() IKey_actionsContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IKey_actionsContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IKey_actionsContext)
}

func (s *ConstraintelemContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *ConstraintelemContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *ConstraintelemContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterConstraintelem(s)
	}
}

func (s *ConstraintelemContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitConstraintelem(s)
	}
}

func (s *ConstraintelemContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitConstraintelem(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Constraintelem() (localctx IConstraintelemContext) {
	localctx = NewConstraintelemContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 210, PostgreSQLParserRULE_constraintelem)
	p.SetState(2995)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetTokenStream().LA(1) {
	case PostgreSQLParserCHECK:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(2937)
			p.Match(PostgreSQLParserCHECK)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2938)
			p.Match(PostgreSQLParserOPEN_PAREN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2939)
			p.A_expr()
		}
		{
			p.SetState(2940)
			p.Match(PostgreSQLParserCLOSE_PAREN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2941)
			p.Constraintattributespec()
		}

	case PostgreSQLParserUNIQUE:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(2943)
			p.Match(PostgreSQLParserUNIQUE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		p.SetState(2955)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}

		switch p.GetTokenStream().LA(1) {
		case PostgreSQLParserOPEN_PAREN:
			{
				p.SetState(2944)
				p.Match(PostgreSQLParserOPEN_PAREN)
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}
			{
				p.SetState(2945)
				p.Columnlist()
			}
			{
				p.SetState(2946)
				p.Match(PostgreSQLParserCLOSE_PAREN)
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}
			{
				p.SetState(2947)
				p.Opt_c_include()
			}
			{
				p.SetState(2948)
				p.Opt_definition()
			}
			{
				p.SetState(2949)
				p.Optconstablespace()
			}
			{
				p.SetState(2950)
				p.Constraintattributespec()
			}

		case PostgreSQLParserUSING:
			{
				p.SetState(2952)
				p.Existingindex()
			}
			{
				p.SetState(2953)
				p.Constraintattributespec()
			}

		default:
			p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
			goto errorExit
		}

	case PostgreSQLParserPRIMARY:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(2957)
			p.Match(PostgreSQLParserPRIMARY)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2958)
			p.Match(PostgreSQLParserKEY)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		p.SetState(2970)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}

		switch p.GetTokenStream().LA(1) {
		case PostgreSQLParserOPEN_PAREN:
			{
				p.SetState(2959)
				p.Match(PostgreSQLParserOPEN_PAREN)
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}
			{
				p.SetState(2960)
				p.Columnlist()
			}
			{
				p.SetState(2961)
				p.Match(PostgreSQLParserCLOSE_PAREN)
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}
			{
				p.SetState(2962)
				p.Opt_c_include()
			}
			{
				p.SetState(2963)
				p.Opt_definition()
			}
			{
				p.SetState(2964)
				p.Optconstablespace()
			}
			{
				p.SetState(2965)
				p.Constraintattributespec()
			}

		case PostgreSQLParserUSING:
			{
				p.SetState(2967)
				p.Existingindex()
			}
			{
				p.SetState(2968)
				p.Constraintattributespec()
			}

		default:
			p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
			goto errorExit
		}

	case PostgreSQLParserEXCLUDE:
		p.EnterOuterAlt(localctx, 4)
		{
			p.SetState(2972)
			p.Match(PostgreSQLParserEXCLUDE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2973)
			p.Access_method_clause()
		}
		{
			p.SetState(2974)
			p.Match(PostgreSQLParserOPEN_PAREN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2975)
			p.Exclusionconstraintlist()
		}
		{
			p.SetState(2976)
			p.Match(PostgreSQLParserCLOSE_PAREN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2977)
			p.Opt_c_include()
		}
		{
			p.SetState(2978)
			p.Opt_definition()
		}
		{
			p.SetState(2979)
			p.Optconstablespace()
		}
		{
			p.SetState(2980)
			p.Exclusionwhereclause()
		}
		{
			p.SetState(2981)
			p.Constraintattributespec()
		}

	case PostgreSQLParserFOREIGN:
		p.EnterOuterAlt(localctx, 5)
		{
			p.SetState(2983)
			p.Match(PostgreSQLParserFOREIGN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2984)
			p.Match(PostgreSQLParserKEY)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2985)
			p.Match(PostgreSQLParserOPEN_PAREN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2986)
			p.Columnlist()
		}
		{
			p.SetState(2987)
			p.Match(PostgreSQLParserCLOSE_PAREN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2988)
			p.Match(PostgreSQLParserREFERENCES)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2989)
			p.Qualified_name()
		}
		{
			p.SetState(2990)
			p.Opt_column_list()
		}
		{
			p.SetState(2991)
			p.Key_match()
		}
		{
			p.SetState(2992)
			p.Key_actions()
		}
		{
			p.SetState(2993)
			p.Constraintattributespec()
		}

	default:
		p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IOpt_no_inheritContext is an interface to support dynamic dispatch.
type IOpt_no_inheritContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	NO() antlr.TerminalNode
	INHERIT() antlr.TerminalNode

	// IsOpt_no_inheritContext differentiates from other interfaces.
	IsOpt_no_inheritContext()
}

type Opt_no_inheritContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyOpt_no_inheritContext() *Opt_no_inheritContext {
	var p = new(Opt_no_inheritContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opt_no_inherit
	return p
}

func InitEmptyOpt_no_inheritContext(p *Opt_no_inheritContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opt_no_inherit
}

func (*Opt_no_inheritContext) IsOpt_no_inheritContext() {}

func NewOpt_no_inheritContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_no_inheritContext {
	var p = new(Opt_no_inheritContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_opt_no_inherit

	return p
}

func (s *Opt_no_inheritContext) GetParser() antlr.Parser { return s.parser }

func (s *Opt_no_inheritContext) NO() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserNO, 0)
}

func (s *Opt_no_inheritContext) INHERIT() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserINHERIT, 0)
}

func (s *Opt_no_inheritContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Opt_no_inheritContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Opt_no_inheritContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterOpt_no_inherit(s)
	}
}

func (s *Opt_no_inheritContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitOpt_no_inherit(s)
	}
}

func (s *Opt_no_inheritContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitOpt_no_inherit(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Opt_no_inherit() (localctx IOpt_no_inheritContext) {
	localctx = NewOpt_no_inheritContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 212, PostgreSQLParserRULE_opt_no_inherit)
	p.SetState(3000)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetTokenStream().LA(1) {
	case PostgreSQLParserNO:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(2997)
			p.Match(PostgreSQLParserNO)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(2998)
			p.Match(PostgreSQLParserINHERIT)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case PostgreSQLParserEOF, PostgreSQLParserOPEN_PAREN, PostgreSQLParserCLOSE_PAREN, PostgreSQLParserCOMMA, PostgreSQLParserSEMI, PostgreSQLParserANALYSE, PostgreSQLParserANALYZE, PostgreSQLParserCHECK, PostgreSQLParserCOLLATE, PostgreSQLParserCONSTRAINT, PostgreSQLParserCREATE, PostgreSQLParserDEFAULT, PostgreSQLParserDEFERRABLE, PostgreSQLParserDO, PostgreSQLParserFETCH, PostgreSQLParserGRANT, PostgreSQLParserINITIALLY, PostgreSQLParserINTO, PostgreSQLParserNOT, PostgreSQLParserNULL_P, PostgreSQLParserPRIMARY, PostgreSQLParserREFERENCES, PostgreSQLParserSELECT, PostgreSQLParserTABLE, PostgreSQLParserUNIQUE, PostgreSQLParserWITH, PostgreSQLParserABORT_P, PostgreSQLParserALTER, PostgreSQLParserBEGIN_P, PostgreSQLParserCHECKPOINT, PostgreSQLParserCLOSE, PostgreSQLParserCLUSTER, PostgreSQLParserCOMMENT, PostgreSQLParserCOMMIT, PostgreSQLParserCOPY, PostgreSQLParserDEALLOCATE, PostgreSQLParserDECLARE, PostgreSQLParserDELETE_P, PostgreSQLParserDISCARD, PostgreSQLParserDROP, PostgreSQLParserEXECUTE, PostgreSQLParserEXPLAIN, PostgreSQLParserINSERT, PostgreSQLParserLISTEN, PostgreSQLParserLOAD, PostgreSQLParserLOCK_P, PostgreSQLParserMERGE, PostgreSQLParserMOVE, PostgreSQLParserNOTIFY, PostgreSQLParserPREPARE, PostgreSQLParserREASSIGN, PostgreSQLParserREFRESH, PostgreSQLParserREINDEX, PostgreSQLParserRELEASE, PostgreSQLParserRESET, PostgreSQLParserREVOKE, PostgreSQLParserROLLBACK, PostgreSQLParserSAVEPOINT, PostgreSQLParserSECURITY, PostgreSQLParserSET, PostgreSQLParserSHOW, PostgreSQLParserSTART, PostgreSQLParserTRUNCATE, PostgreSQLParserUNLISTEN, PostgreSQLParserUPDATE, PostgreSQLParserVACUUM, PostgreSQLParserVALUES, PostgreSQLParserCALL, PostgreSQLParserGENERATED, PostgreSQLParserIMPORT_P, PostgreSQLParserEND_P, PostgreSQLParserMetaCommand:
		p.EnterOuterAlt(localctx, 2)

	default:
		p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IOpt_column_listContext is an interface to support dynamic dispatch.
type IOpt_column_listContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	OPEN_PAREN() antlr.TerminalNode
	Columnlist() IColumnlistContext
	CLOSE_PAREN() antlr.TerminalNode

	// IsOpt_column_listContext differentiates from other interfaces.
	IsOpt_column_listContext()
}

type Opt_column_listContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyOpt_column_listContext() *Opt_column_listContext {
	var p = new(Opt_column_listContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opt_column_list
	return p
}

func InitEmptyOpt_column_listContext(p *Opt_column_listContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opt_column_list
}

func (*Opt_column_listContext) IsOpt_column_listContext() {}

func NewOpt_column_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_column_listContext {
	var p = new(Opt_column_listContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_opt_column_list

	return p
}

func (s *Opt_column_listContext) GetParser() antlr.Parser { return s.parser }

func (s *Opt_column_listContext) OPEN_PAREN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserOPEN_PAREN, 0)
}

func (s *Opt_column_listContext) Columnlist() IColumnlistContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IColumnlistContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IColumnlistContext)
}

func (s *Opt_column_listContext) CLOSE_PAREN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCLOSE_PAREN, 0)
}

func (s *Opt_column_listContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Opt_column_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Opt_column_listContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterOpt_column_list(s)
	}
}

func (s *Opt_column_listContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitOpt_column_list(s)
	}
}

func (s *Opt_column_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitOpt_column_list(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Opt_column_list() (localctx IOpt_column_listContext) {
	localctx = NewOpt_column_listContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 214, PostgreSQLParserRULE_opt_column_list)
	p.SetState(3007)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 103, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(3002)
			p.Match(PostgreSQLParserOPEN_PAREN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(3003)
			p.Columnlist()
		}
		{
			p.SetState(3004)
			p.Match(PostgreSQLParserCLOSE_PAREN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)

	case antlr.ATNInvalidAltNumber:
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IColumnlistContext is an interface to support dynamic dispatch.
type IColumnlistContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	AllColumnElem() []IColumnElemContext
	ColumnElem(i int) IColumnElemContext
	AllCOMMA() []antlr.TerminalNode
	COMMA(i int) antlr.TerminalNode

	// IsColumnlistContext differentiates from other interfaces.
	IsColumnlistContext()
}

type ColumnlistContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyColumnlistContext() *ColumnlistContext {
	var p = new(ColumnlistContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_columnlist
	return p
}

func InitEmptyColumnlistContext(p *ColumnlistContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_columnlist
}

func (*ColumnlistContext) IsColumnlistContext() {}

func NewColumnlistContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ColumnlistContext {
	var p = new(ColumnlistContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_columnlist

	return p
}

func (s *ColumnlistContext) GetParser() antlr.Parser { return s.parser }

func (s *ColumnlistContext) AllColumnElem() []IColumnElemContext {
	children := s.GetChildren()
	len := 0
	for _, ctx := range children {
		if _, ok := ctx.(IColumnElemContext); ok {
			len++
		}
	}

	tst := make([]IColumnElemContext, len)
	i := 0
	for _, ctx := range children {
		if t, ok := ctx.(IColumnElemContext); ok {
			tst[i] = t.(IColumnElemContext)
			i++
		}
	}

	return tst
}

func (s *ColumnlistContext) ColumnElem(i int) IColumnElemContext {
	var t antlr.RuleContext
	j := 0
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IColumnElemContext); ok {
			if j == i {
				t = ctx.(antlr.RuleContext)
				break
			}
			j++
		}
	}

	if t == nil {
		return nil
	}

	return t.(IColumnElemContext)
}

func (s *ColumnlistContext) AllCOMMA() []antlr.TerminalNode {
	return s.GetTokens(PostgreSQLParserCOMMA)
}

func (s *ColumnlistContext) COMMA(i int) antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCOMMA, i)
}

func (s *ColumnlistContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *ColumnlistContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *ColumnlistContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterColumnlist(s)
	}
}

func (s *ColumnlistContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitColumnlist(s)
	}
}

func (s *ColumnlistContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitColumnlist(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Columnlist() (localctx IColumnlistContext) {
	localctx = NewColumnlistContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 216, PostgreSQLParserRULE_columnlist)
	var _la int

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(3009)
		p.ColumnElem()
	}
	p.SetState(3014)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}
	_la = p.GetTokenStream().LA(1)

	for _la == PostgreSQLParserCOMMA {
		{
			p.SetState(3010)
			p.Match(PostgreSQLParserCOMMA)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(3011)
			p.ColumnElem()
		}

		p.SetState(3016)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}
		_la = p.GetTokenStream().LA(1)
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IColumnElemContext is an interface to support dynamic dispatch.
type IColumnElemContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Colid() IColidContext

	// IsColumnElemContext differentiates from other interfaces.
	IsColumnElemContext()
}

type ColumnElemContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyColumnElemContext() *ColumnElemContext {
	var p = new(ColumnElemContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_columnElem
	return p
}

func InitEmptyColumnElemContext(p *ColumnElemContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_columnElem
}

func (*ColumnElemContext) IsColumnElemContext() {}

func NewColumnElemContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ColumnElemContext {
	var p = new(ColumnElemContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_columnElem

	return p
}

func (s *ColumnElemContext) GetParser() antlr.Parser { return s.parser }

func (s *ColumnElemContext) Colid() IColidContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IColidContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IColidContext)
}

func (s *ColumnElemContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *ColumnElemContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *ColumnElemContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterColumnElem(s)
	}
}

func (s *ColumnElemContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitColumnElem(s)
	}
}

func (s *ColumnElemContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitColumnElem(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) ColumnElem() (localctx IColumnElemContext) {
	localctx = NewColumnElemContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 218, PostgreSQLParserRULE_columnElem)
	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(3017)
		p.Colid()
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IOpt_c_includeContext is an interface to support dynamic dispatch.
type IOpt_c_includeContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	INCLUDE() antlr.TerminalNode
	OPEN_PAREN() antlr.TerminalNode
	Columnlist() IColumnlistContext
	CLOSE_PAREN() antlr.TerminalNode

	// IsOpt_c_includeContext differentiates from other interfaces.
	IsOpt_c_includeContext()
}

type Opt_c_includeContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyOpt_c_includeContext() *Opt_c_includeContext {
	var p = new(Opt_c_includeContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opt_c_include
	return p
}

func InitEmptyOpt_c_includeContext(p *Opt_c_includeContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opt_c_include
}

func (*Opt_c_includeContext) IsOpt_c_includeContext() {}

func NewOpt_c_includeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_c_includeContext {
	var p = new(Opt_c_includeContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_opt_c_include

	return p
}

func (s *Opt_c_includeContext) GetParser() antlr.Parser { return s.parser }

func (s *Opt_c_includeContext) INCLUDE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserINCLUDE, 0)
}

func (s *Opt_c_includeContext) OPEN_PAREN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserOPEN_PAREN, 0)
}

func (s *Opt_c_includeContext) Columnlist() IColumnlistContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IColumnlistContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IColumnlistContext)
}

func (s *Opt_c_includeContext) CLOSE_PAREN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCLOSE_PAREN, 0)
}

func (s *Opt_c_includeContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Opt_c_includeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Opt_c_includeContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterOpt_c_include(s)
	}
}

func (s *Opt_c_includeContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitOpt_c_include(s)
	}
}

func (s *Opt_c_includeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitOpt_c_include(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Opt_c_include() (localctx IOpt_c_includeContext) {
	localctx = NewOpt_c_includeContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 220, PostgreSQLParserRULE_opt_c_include)
	p.SetState(3025)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetTokenStream().LA(1) {
	case PostgreSQLParserINCLUDE:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(3019)
			p.Match(PostgreSQLParserINCLUDE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(3020)
			p.Match(PostgreSQLParserOPEN_PAREN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(3021)
			p.Columnlist()
		}
		{
			p.SetState(3022)
			p.Match(PostgreSQLParserCLOSE_PAREN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case PostgreSQLParserEOF, PostgreSQLParserOPEN_PAREN, PostgreSQLParserCLOSE_PAREN, PostgreSQLParserCOMMA, PostgreSQLParserSEMI, PostgreSQLParserANALYSE, PostgreSQLParserANALYZE, PostgreSQLParserCREATE, PostgreSQLParserDEFERRABLE, PostgreSQLParserDO, PostgreSQLParserFETCH, PostgreSQLParserGRANT, PostgreSQLParserINITIALLY, PostgreSQLParserINTO, PostgreSQLParserNOT, PostgreSQLParserSELECT, PostgreSQLParserTABLE, PostgreSQLParserUSING, PostgreSQLParserWHERE, PostgreSQLParserWITH, PostgreSQLParserABORT_P, PostgreSQLParserALTER, PostgreSQLParserBEGIN_P, PostgreSQLParserCHECKPOINT, PostgreSQLParserCLOSE, PostgreSQLParserCLUSTER, PostgreSQLParserCOMMENT, PostgreSQLParserCOMMIT, PostgreSQLParserCOPY, PostgreSQLParserDEALLOCATE, PostgreSQLParserDECLARE, PostgreSQLParserDELETE_P, PostgreSQLParserDISCARD, PostgreSQLParserDROP, PostgreSQLParserEXECUTE, PostgreSQLParserEXPLAIN, PostgreSQLParserINSERT, PostgreSQLParserLISTEN, PostgreSQLParserLOAD, PostgreSQLParserLOCK_P, PostgreSQLParserMERGE, PostgreSQLParserMOVE, PostgreSQLParserNO, PostgreSQLParserNOTIFY, PostgreSQLParserPREPARE, PostgreSQLParserREASSIGN, PostgreSQLParserREFRESH, PostgreSQLParserREINDEX, PostgreSQLParserRELEASE, PostgreSQLParserRESET, PostgreSQLParserREVOKE, PostgreSQLParserROLLBACK, PostgreSQLParserSAVEPOINT, PostgreSQLParserSECURITY, PostgreSQLParserSET, PostgreSQLParserSHOW, PostgreSQLParserSTART, PostgreSQLParserTRUNCATE, PostgreSQLParserUNLISTEN, PostgreSQLParserUPDATE, PostgreSQLParserVACUUM, PostgreSQLParserVALUES, PostgreSQLParserCALL, PostgreSQLParserIMPORT_P, PostgreSQLParserEND_P, PostgreSQLParserMetaCommand:
		p.EnterOuterAlt(localctx, 2)

	default:
		p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IKey_matchContext is an interface to support dynamic dispatch.
type IKey_matchContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	MATCH() antlr.TerminalNode
	FULL() antlr.TerminalNode
	PARTIAL() antlr.TerminalNode
	SIMPLE() antlr.TerminalNode

	// IsKey_matchContext differentiates from other interfaces.
	IsKey_matchContext()
}

type Key_matchContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyKey_matchContext() *Key_matchContext {
	var p = new(Key_matchContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_key_match
	return p
}

func InitEmptyKey_matchContext(p *Key_matchContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_key_match
}

func (*Key_matchContext) IsKey_matchContext() {}

func NewKey_matchContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Key_matchContext {
	var p = new(Key_matchContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_key_match

	return p
}

func (s *Key_matchContext) GetParser() antlr.Parser { return s.parser }

func (s *Key_matchContext) MATCH() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserMATCH, 0)
}

func (s *Key_matchContext) FULL() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserFULL, 0)
}

func (s *Key_matchContext) PARTIAL() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserPARTIAL, 0)
}

func (s *Key_matchContext) SIMPLE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserSIMPLE, 0)
}

func (s *Key_matchContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Key_matchContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Key_matchContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterKey_match(s)
	}
}

func (s *Key_matchContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitKey_match(s)
	}
}

func (s *Key_matchContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitKey_match(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Key_match() (localctx IKey_matchContext) {
	localctx = NewKey_matchContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 222, PostgreSQLParserRULE_key_match)
	var _la int

	p.SetState(3030)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetTokenStream().LA(1) {
	case PostgreSQLParserMATCH:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(3027)
			p.Match(PostgreSQLParserMATCH)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(3028)
			_la = p.GetTokenStream().LA(1)

			if !(_la == PostgreSQLParserFULL || _la == PostgreSQLParserPARTIAL || _la == PostgreSQLParserSIMPLE) {
				p.GetErrorHandler().RecoverInline(p)
			} else {
				p.GetErrorHandler().ReportMatch(p)
				p.Consume()
			}
		}

	case PostgreSQLParserEOF, PostgreSQLParserOPEN_PAREN, PostgreSQLParserCLOSE_PAREN, PostgreSQLParserCOMMA, PostgreSQLParserSEMI, PostgreSQLParserANALYSE, PostgreSQLParserANALYZE, PostgreSQLParserCHECK, PostgreSQLParserCOLLATE, PostgreSQLParserCONSTRAINT, PostgreSQLParserCREATE, PostgreSQLParserDEFAULT, PostgreSQLParserDEFERRABLE, PostgreSQLParserDO, PostgreSQLParserFETCH, PostgreSQLParserGRANT, PostgreSQLParserINITIALLY, PostgreSQLParserINTO, PostgreSQLParserNOT, PostgreSQLParserNULL_P, PostgreSQLParserON, PostgreSQLParserPRIMARY, PostgreSQLParserREFERENCES, PostgreSQLParserSELECT, PostgreSQLParserTABLE, PostgreSQLParserUNIQUE, PostgreSQLParserWITH, PostgreSQLParserABORT_P, PostgreSQLParserALTER, PostgreSQLParserBEGIN_P, PostgreSQLParserCHECKPOINT, PostgreSQLParserCLOSE, PostgreSQLParserCLUSTER, PostgreSQLParserCOMMENT, PostgreSQLParserCOMMIT, PostgreSQLParserCOPY, PostgreSQLParserDEALLOCATE, PostgreSQLParserDECLARE, PostgreSQLParserDELETE_P, PostgreSQLParserDISCARD, PostgreSQLParserDROP, PostgreSQLParserEXECUTE, PostgreSQLParserEXPLAIN, PostgreSQLParserINSERT, PostgreSQLParserLISTEN, PostgreSQLParserLOAD, PostgreSQLParserLOCK_P, PostgreSQLParserMERGE, PostgreSQLParserMOVE, PostgreSQLParserNO, PostgreSQLParserNOTIFY, PostgreSQLParserPREPARE, PostgreSQLParserREASSIGN, PostgreSQLParserREFRESH, PostgreSQLParserREINDEX, PostgreSQLParserRELEASE, PostgreSQLParserRESET, PostgreSQLParserREVOKE, PostgreSQLParserROLLBACK, PostgreSQLParserSAVEPOINT, PostgreSQLParserSECURITY, PostgreSQLParserSET, PostgreSQLParserSHOW, PostgreSQLParserSTART, PostgreSQLParserTRUNCATE, PostgreSQLParserUNLISTEN, PostgreSQLParserUPDATE, PostgreSQLParserVACUUM, PostgreSQLParserVALUES, PostgreSQLParserCALL, PostgreSQLParserGENERATED, PostgreSQLParserIMPORT_P, PostgreSQLParserEND_P, PostgreSQLParserMetaCommand:
		p.EnterOuterAlt(localctx, 2)

	default:
		p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IExclusionconstraintlistContext is an interface to support dynamic dispatch.
type IExclusionconstraintlistContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	AllExclusionconstraintelem() []IExclusionconstraintelemContext
	Exclusionconstraintelem(i int) IExclusionconstraintelemContext
	AllCOMMA() []antlr.TerminalNode
	COMMA(i int) antlr.TerminalNode

	// IsExclusionconstraintlistContext differentiates from other interfaces.
	IsExclusionconstraintlistContext()
}

type ExclusionconstraintlistContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyExclusionconstraintlistContext() *ExclusionconstraintlistContext {
	var p = new(ExclusionconstraintlistContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_exclusionconstraintlist
	return p
}

func InitEmptyExclusionconstraintlistContext(p *ExclusionconstraintlistContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_exclusionconstraintlist
}

func (*ExclusionconstraintlistContext) IsExclusionconstraintlistContext() {}

func NewExclusionconstraintlistContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ExclusionconstraintlistContext {
	var p = new(ExclusionconstraintlistContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_exclusionconstraintlist

	return p
}

func (s *ExclusionconstraintlistContext) GetParser() antlr.Parser { return s.parser }

func (s *ExclusionconstraintlistContext) AllExclusionconstraintelem() []IExclusionconstraintelemContext {
	children := s.GetChildren()
	len := 0
	for _, ctx := range children {
		if _, ok := ctx.(IExclusionconstraintelemContext); ok {
			len++
		}
	}

	tst := make([]IExclusionconstraintelemContext, len)
	i := 0
	for _, ctx := range children {
		if t, ok := ctx.(IExclusionconstraintelemContext); ok {
			tst[i] = t.(IExclusionconstraintelemContext)
			i++
		}
	}

	return tst
}

func (s *ExclusionconstraintlistContext) Exclusionconstraintelem(i int) IExclusionconstraintelemContext {
	var t antlr.RuleContext
	j := 0
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IExclusionconstraintelemContext); ok {
			if j == i {
				t = ctx.(antlr.RuleContext)
				break
			}
			j++
		}
	}

	if t == nil {
		return nil
	}

	return t.(IExclusionconstraintelemContext)
}

func (s *ExclusionconstraintlistContext) AllCOMMA() []antlr.TerminalNode {
	return s.GetTokens(PostgreSQLParserCOMMA)
}

func (s *ExclusionconstraintlistContext) COMMA(i int) antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCOMMA, i)
}

func (s *ExclusionconstraintlistContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *ExclusionconstraintlistContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *ExclusionconstraintlistContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterExclusionconstraintlist(s)
	}
}

func (s *ExclusionconstraintlistContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitExclusionconstraintlist(s)
	}
}

func (s *ExclusionconstraintlistContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitExclusionconstraintlist(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Exclusionconstraintlist() (localctx IExclusionconstraintlistContext) {
	localctx = NewExclusionconstraintlistContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 224, PostgreSQLParserRULE_exclusionconstraintlist)
	var _la int

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(3032)
		p.Exclusionconstraintelem()
	}
	p.SetState(3037)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}
	_la = p.GetTokenStream().LA(1)

	for _la == PostgreSQLParserCOMMA {
		{
			p.SetState(3033)
			p.Match(PostgreSQLParserCOMMA)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(3034)
			p.Exclusionconstraintelem()
		}

		p.SetState(3039)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}
		_la = p.GetTokenStream().LA(1)
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IExclusionconstraintelemContext is an interface to support dynamic dispatch.
type IExclusionconstraintelemContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Index_elem() IIndex_elemContext
	WITH() antlr.TerminalNode
	Any_operator() IAny_operatorContext
	OPERATOR() antlr.TerminalNode
	OPEN_PAREN() antlr.TerminalNode
	CLOSE_PAREN() antlr.TerminalNode

	// IsExclusionconstraintelemContext differentiates from other interfaces.
	IsExclusionconstraintelemContext()
}

type ExclusionconstraintelemContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyExclusionconstraintelemContext() *ExclusionconstraintelemContext {
	var p = new(ExclusionconstraintelemContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_exclusionconstraintelem
	return p
}

func InitEmptyExclusionconstraintelemContext(p *ExclusionconstraintelemContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_exclusionconstraintelem
}

func (*ExclusionconstraintelemContext) IsExclusionconstraintelemContext() {}

func NewExclusionconstraintelemContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ExclusionconstraintelemContext {
	var p = new(ExclusionconstraintelemContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_exclusionconstraintelem

	return p
}

func (s *ExclusionconstraintelemContext) GetParser() antlr.Parser { return s.parser }

func (s *ExclusionconstraintelemContext) Index_elem() IIndex_elemContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IIndex_elemContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IIndex_elemContext)
}

func (s *ExclusionconstraintelemContext) WITH() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserWITH, 0)
}

func (s *ExclusionconstraintelemContext) Any_operator() IAny_operatorContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IAny_operatorContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IAny_operatorContext)
}

func (s *ExclusionconstraintelemContext) OPERATOR() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserOPERATOR, 0)
}

func (s *ExclusionconstraintelemContext) OPEN_PAREN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserOPEN_PAREN, 0)
}

func (s *ExclusionconstraintelemContext) CLOSE_PAREN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCLOSE_PAREN, 0)
}

func (s *ExclusionconstraintelemContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *ExclusionconstraintelemContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *ExclusionconstraintelemContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterExclusionconstraintelem(s)
	}
}

func (s *ExclusionconstraintelemContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitExclusionconstraintelem(s)
	}
}

func (s *ExclusionconstraintelemContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitExclusionconstraintelem(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Exclusionconstraintelem() (localctx IExclusionconstraintelemContext) {
	localctx = NewExclusionconstraintelemContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 226, PostgreSQLParserRULE_exclusionconstraintelem)
	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(3040)
		p.Index_elem()
	}
	{
		p.SetState(3041)
		p.Match(PostgreSQLParserWITH)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	p.SetState(3048)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 108, p.GetParserRuleContext()) {
	case 1:
		{
			p.SetState(3042)
			p.Any_operator()
		}

	case 2:
		{
			p.SetState(3043)
			p.Match(PostgreSQLParserOPERATOR)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(3044)
			p.Match(PostgreSQLParserOPEN_PAREN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(3045)
			p.Any_operator()
		}
		{
			p.SetState(3046)
			p.Match(PostgreSQLParserCLOSE_PAREN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case antlr.ATNInvalidAltNumber:
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IExclusionwhereclauseContext is an interface to support dynamic dispatch.
type IExclusionwhereclauseContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	WHERE() antlr.TerminalNode
	OPEN_PAREN() antlr.TerminalNode
	A_expr() IA_exprContext
	CLOSE_PAREN() antlr.TerminalNode

	// IsExclusionwhereclauseContext differentiates from other interfaces.
	IsExclusionwhereclauseContext()
}

type ExclusionwhereclauseContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyExclusionwhereclauseContext() *ExclusionwhereclauseContext {
	var p = new(ExclusionwhereclauseContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_exclusionwhereclause
	return p
}

func InitEmptyExclusionwhereclauseContext(p *ExclusionwhereclauseContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_exclusionwhereclause
}

func (*ExclusionwhereclauseContext) IsExclusionwhereclauseContext() {}

func NewExclusionwhereclauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ExclusionwhereclauseContext {
	var p = new(ExclusionwhereclauseContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_exclusionwhereclause

	return p
}

func (s *ExclusionwhereclauseContext) GetParser() antlr.Parser { return s.parser }

func (s *ExclusionwhereclauseContext) WHERE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserWHERE, 0)
}

func (s *ExclusionwhereclauseContext) OPEN_PAREN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserOPEN_PAREN, 0)
}

func (s *ExclusionwhereclauseContext) A_expr() IA_exprContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IA_exprContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IA_exprContext)
}

func (s *ExclusionwhereclauseContext) CLOSE_PAREN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCLOSE_PAREN, 0)
}

func (s *ExclusionwhereclauseContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *ExclusionwhereclauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *ExclusionwhereclauseContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterExclusionwhereclause(s)
	}
}

func (s *ExclusionwhereclauseContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitExclusionwhereclause(s)
	}
}

func (s *ExclusionwhereclauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitExclusionwhereclause(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Exclusionwhereclause() (localctx IExclusionwhereclauseContext) {
	localctx = NewExclusionwhereclauseContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 228, PostgreSQLParserRULE_exclusionwhereclause)
	p.SetState(3056)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetTokenStream().LA(1) {
	case PostgreSQLParserWHERE:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(3050)
			p.Match(PostgreSQLParserWHERE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(3051)
			p.Match(PostgreSQLParserOPEN_PAREN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(3052)
			p.A_expr()
		}
		{
			p.SetState(3053)
			p.Match(PostgreSQLParserCLOSE_PAREN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case PostgreSQLParserEOF, PostgreSQLParserOPEN_PAREN, PostgreSQLParserCLOSE_PAREN, PostgreSQLParserCOMMA, PostgreSQLParserSEMI, PostgreSQLParserANALYSE, PostgreSQLParserANALYZE, PostgreSQLParserCREATE, PostgreSQLParserDEFERRABLE, PostgreSQLParserDO, PostgreSQLParserFETCH, PostgreSQLParserGRANT, PostgreSQLParserINITIALLY, PostgreSQLParserINTO, PostgreSQLParserNOT, PostgreSQLParserSELECT, PostgreSQLParserTABLE, PostgreSQLParserWITH, PostgreSQLParserABORT_P, PostgreSQLParserALTER, PostgreSQLParserBEGIN_P, PostgreSQLParserCHECKPOINT, PostgreSQLParserCLOSE, PostgreSQLParserCLUSTER, PostgreSQLParserCOMMENT, PostgreSQLParserCOMMIT, PostgreSQLParserCOPY, PostgreSQLParserDEALLOCATE, PostgreSQLParserDECLARE, PostgreSQLParserDELETE_P, PostgreSQLParserDISCARD, PostgreSQLParserDROP, PostgreSQLParserEXECUTE, PostgreSQLParserEXPLAIN, PostgreSQLParserINSERT, PostgreSQLParserLISTEN, PostgreSQLParserLOAD, PostgreSQLParserLOCK_P, PostgreSQLParserMERGE, PostgreSQLParserMOVE, PostgreSQLParserNO, PostgreSQLParserNOTIFY, PostgreSQLParserPREPARE, PostgreSQLParserREASSIGN, PostgreSQLParserREFRESH, PostgreSQLParserREINDEX, PostgreSQLParserRELEASE, PostgreSQLParserRESET, PostgreSQLParserREVOKE, PostgreSQLParserROLLBACK, PostgreSQLParserSAVEPOINT, PostgreSQLParserSECURITY, PostgreSQLParserSET, PostgreSQLParserSHOW, PostgreSQLParserSTART, PostgreSQLParserTRUNCATE, PostgreSQLParserUNLISTEN, PostgreSQLParserUPDATE, PostgreSQLParserVACUUM, PostgreSQLParserVALUES, PostgreSQLParserCALL, PostgreSQLParserIMPORT_P, PostgreSQLParserEND_P, PostgreSQLParserMetaCommand:
		p.EnterOuterAlt(localctx, 2)

	default:
		p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IKey_actionsContext is an interface to support dynamic dispatch.
type IKey_actionsContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Key_update() IKey_updateContext
	Key_delete() IKey_deleteContext

	// IsKey_actionsContext differentiates from other interfaces.
	IsKey_actionsContext()
}

type Key_actionsContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyKey_actionsContext() *Key_actionsContext {
	var p = new(Key_actionsContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_key_actions
	return p
}

func InitEmptyKey_actionsContext(p *Key_actionsContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_key_actions
}

func (*Key_actionsContext) IsKey_actionsContext() {}

func NewKey_actionsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Key_actionsContext {
	var p = new(Key_actionsContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_key_actions

	return p
}

func (s *Key_actionsContext) GetParser() antlr.Parser { return s.parser }

func (s *Key_actionsContext) Key_update() IKey_updateContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IKey_updateContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IKey_updateContext)
}

func (s *Key_actionsContext) Key_delete() IKey_deleteContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IKey_deleteContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IKey_deleteContext)
}

func (s *Key_actionsContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Key_actionsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Key_actionsContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterKey_actions(s)
	}
}

func (s *Key_actionsContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitKey_actions(s)
	}
}

func (s *Key_actionsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitKey_actions(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Key_actions() (localctx IKey_actionsContext) {
	localctx = NewKey_actionsContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 230, PostgreSQLParserRULE_key_actions)
	p.SetState(3067)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 110, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(3058)
			p.Key_update()
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(3059)
			p.Key_delete()
		}

	case 3:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(3060)
			p.Key_update()
		}
		{
			p.SetState(3061)
			p.Key_delete()
		}

	case 4:
		p.EnterOuterAlt(localctx, 4)
		{
			p.SetState(3063)
			p.Key_delete()
		}
		{
			p.SetState(3064)
			p.Key_update()
		}

	case 5:
		p.EnterOuterAlt(localctx, 5)

	case antlr.ATNInvalidAltNumber:
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IKey_updateContext is an interface to support dynamic dispatch.
type IKey_updateContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	ON() antlr.TerminalNode
	UPDATE() antlr.TerminalNode
	Key_action() IKey_actionContext

	// IsKey_updateContext differentiates from other interfaces.
	IsKey_updateContext()
}

type Key_updateContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyKey_updateContext() *Key_updateContext {
	var p = new(Key_updateContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_key_update
	return p
}

func InitEmptyKey_updateContext(p *Key_updateContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_key_update
}

func (*Key_updateContext) IsKey_updateContext() {}

func NewKey_updateContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Key_updateContext {
	var p = new(Key_updateContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_key_update

	return p
}

func (s *Key_updateContext) GetParser() antlr.Parser { return s.parser }

func (s *Key_updateContext) ON() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserON, 0)
}

func (s *Key_updateContext) UPDATE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserUPDATE, 0)
}

func (s *Key_updateContext) Key_action() IKey_actionContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IKey_actionContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IKey_actionContext)
}

func (s *Key_updateContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Key_updateContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Key_updateContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterKey_update(s)
	}
}

func (s *Key_updateContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitKey_update(s)
	}
}

func (s *Key_updateContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitKey_update(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Key_update() (localctx IKey_updateContext) {
	localctx = NewKey_updateContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 232, PostgreSQLParserRULE_key_update)
	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(3069)
		p.Match(PostgreSQLParserON)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(3070)
		p.Match(PostgreSQLParserUPDATE)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(3071)
		p.Key_action()
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IKey_deleteContext is an interface to support dynamic dispatch.
type IKey_deleteContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	ON() antlr.TerminalNode
	DELETE_P() antlr.TerminalNode
	Key_action() IKey_actionContext

	// IsKey_deleteContext differentiates from other interfaces.
	IsKey_deleteContext()
}

type Key_deleteContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyKey_deleteContext() *Key_deleteContext {
	var p = new(Key_deleteContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_key_delete
	return p
}

func InitEmptyKey_deleteContext(p *Key_deleteContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_key_delete
}

func (*Key_deleteContext) IsKey_deleteContext() {}

func NewKey_deleteContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Key_deleteContext {
	var p = new(Key_deleteContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_key_delete

	return p
}

func (s *Key_deleteContext) GetParser() antlr.Parser { return s.parser }

func (s *Key_deleteContext) ON() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserON, 0)
}

func (s *Key_deleteContext) DELETE_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserDELETE_P, 0)
}

func (s *Key_deleteContext) Key_action() IKey_actionContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IKey_actionContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IKey_actionContext)
}

func (s *Key_deleteContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Key_deleteContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Key_deleteContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterKey_delete(s)
	}
}

func (s *Key_deleteContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitKey_delete(s)
	}
}

func (s *Key_deleteContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitKey_delete(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Key_delete() (localctx IKey_deleteContext) {
	localctx = NewKey_deleteContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 234, PostgreSQLParserRULE_key_delete)
	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(3073)
		p.Match(PostgreSQLParserON)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(3074)
		p.Match(PostgreSQLParserDELETE_P)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(3075)
		p.Key_action()
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IKey_actionContext is an interface to support dynamic dispatch.
type IKey_actionContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	NO() antlr.TerminalNode
	ACTION() antlr.TerminalNode
	RESTRICT() antlr.TerminalNode
	CASCADE() antlr.TerminalNode
	SET() antlr.TerminalNode
	NULL_P() antlr.TerminalNode
	DEFAULT() antlr.TerminalNode

	// IsKey_actionContext differentiates from other interfaces.
	IsKey_actionContext()
}

type Key_actionContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyKey_actionContext() *Key_actionContext {
	var p = new(Key_actionContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_key_action
	return p
}

func InitEmptyKey_actionContext(p *Key_actionContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_key_action
}

func (*Key_actionContext) IsKey_actionContext() {}

func NewKey_actionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Key_actionContext {
	var p = new(Key_actionContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_key_action

	return p
}

func (s *Key_actionContext) GetParser() antlr.Parser { return s.parser }

func (s *Key_actionContext) NO() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserNO, 0)
}

func (s *Key_actionContext) ACTION() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserACTION, 0)
}

func (s *Key_actionContext) RESTRICT() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserRESTRICT, 0)
}

func (s *Key_actionContext) CASCADE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCASCADE, 0)
}

func (s *Key_actionContext) SET() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserSET, 0)
}

func (s *Key_actionContext) NULL_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserNULL_P, 0)
}

func (s *Key_actionContext) DEFAULT() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserDEFAULT, 0)
}

func (s *Key_actionContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Key_actionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Key_actionContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterKey_action(s)
	}
}

func (s *Key_actionContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitKey_action(s)
	}
}

func (s *Key_actionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitKey_action(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Key_action() (localctx IKey_actionContext) {
	localctx = NewKey_actionContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 236, PostgreSQLParserRULE_key_action)
	var _la int

	p.SetState(3083)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetTokenStream().LA(1) {
	case PostgreSQLParserNO:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(3077)
			p.Match(PostgreSQLParserNO)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(3078)
			p.Match(PostgreSQLParserACTION)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case PostgreSQLParserRESTRICT:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(3079)
			p.Match(PostgreSQLParserRESTRICT)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case PostgreSQLParserCASCADE:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(3080)
			p.Match(PostgreSQLParserCASCADE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case PostgreSQLParserSET:
		p.EnterOuterAlt(localctx, 4)
		{
			p.SetState(3081)
			p.Match(PostgreSQLParserSET)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(3082)
			_la = p.GetTokenStream().LA(1)

			if !(_la == PostgreSQLParserDEFAULT || _la == PostgreSQLParserNULL_P) {
				p.GetErrorHandler().RecoverInline(p)
			} else {
				p.GetErrorHandler().ReportMatch(p)
				p.Consume()
			}
		}

	default:
		p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IOptinheritContext is an interface to support dynamic dispatch.
type IOptinheritContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	INHERITS() antlr.TerminalNode
	OPEN_PAREN() antlr.TerminalNode
	Qualified_name_list() IQualified_name_listContext
	CLOSE_PAREN() antlr.TerminalNode

	// IsOptinheritContext differentiates from other interfaces.
	IsOptinheritContext()
}

type OptinheritContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyOptinheritContext() *OptinheritContext {
	var p = new(OptinheritContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_optinherit
	return p
}

func InitEmptyOptinheritContext(p *OptinheritContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_optinherit
}

func (*OptinheritContext) IsOptinheritContext() {}

func NewOptinheritContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *OptinheritContext {
	var p = new(OptinheritContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_optinherit

	return p
}

func (s *OptinheritContext) GetParser() antlr.Parser { return s.parser }

func (s *OptinheritContext) INHERITS() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserINHERITS, 0)
}

func (s *OptinheritContext) OPEN_PAREN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserOPEN_PAREN, 0)
}

func (s *OptinheritContext) Qualified_name_list() IQualified_name_listContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IQualified_name_listContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IQualified_name_listContext)
}

func (s *OptinheritContext) CLOSE_PAREN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCLOSE_PAREN, 0)
}

func (s *OptinheritContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *OptinheritContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *OptinheritContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterOptinherit(s)
	}
}

func (s *OptinheritContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitOptinherit(s)
	}
}

func (s *OptinheritContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitOptinherit(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Optinherit() (localctx IOptinheritContext) {
	localctx = NewOptinheritContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 238, PostgreSQLParserRULE_optinherit)
	p.SetState(3091)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetTokenStream().LA(1) {
	case PostgreSQLParserINHERITS:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(3085)
			p.Match(PostgreSQLParserINHERITS)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(3086)
			p.Match(PostgreSQLParserOPEN_PAREN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(3087)
			p.Qualified_name_list()
		}
		{
			p.SetState(3088)
			p.Match(PostgreSQLParserCLOSE_PAREN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case PostgreSQLParserEOF, PostgreSQLParserOPEN_PAREN, PostgreSQLParserSEMI, PostgreSQLParserANALYSE, PostgreSQLParserANALYZE, PostgreSQLParserCREATE, PostgreSQLParserDO, PostgreSQLParserFETCH, PostgreSQLParserGRANT, PostgreSQLParserINTO, PostgreSQLParserON, PostgreSQLParserSELECT, PostgreSQLParserTABLE, PostgreSQLParserUSING, PostgreSQLParserWITH, PostgreSQLParserABORT_P, PostgreSQLParserALTER, PostgreSQLParserBEGIN_P, PostgreSQLParserCHECKPOINT, PostgreSQLParserCLOSE, PostgreSQLParserCLUSTER, PostgreSQLParserCOMMENT, PostgreSQLParserCOMMIT, PostgreSQLParserCOPY, PostgreSQLParserDEALLOCATE, PostgreSQLParserDECLARE, PostgreSQLParserDELETE_P, PostgreSQLParserDISCARD, PostgreSQLParserDROP, PostgreSQLParserEXECUTE, PostgreSQLParserEXPLAIN, PostgreSQLParserINSERT, PostgreSQLParserLISTEN, PostgreSQLParserLOAD, PostgreSQLParserLOCK_P, PostgreSQLParserMERGE, PostgreSQLParserMOVE, PostgreSQLParserNOTIFY, PostgreSQLParserPARTITION, PostgreSQLParserPREPARE, PostgreSQLParserREASSIGN, PostgreSQLParserREFRESH, PostgreSQLParserREINDEX, PostgreSQLParserRELEASE, PostgreSQLParserRESET, PostgreSQLParserREVOKE, PostgreSQLParserROLLBACK, PostgreSQLParserSAVEPOINT, PostgreSQLParserSECURITY, PostgreSQLParserSERVER, PostgreSQLParserSET, PostgreSQLParserSHOW, PostgreSQLParserSTART, PostgreSQLParserTABLESPACE, PostgreSQLParserTRUNCATE, PostgreSQLParserUNLISTEN, PostgreSQLParserUPDATE, PostgreSQLParserVACUUM, PostgreSQLParserWITHOUT, PostgreSQLParserVALUES, PostgreSQLParserCALL, PostgreSQLParserIMPORT_P, PostgreSQLParserEND_P, PostgreSQLParserMetaCommand:
		p.EnterOuterAlt(localctx, 2)

	default:
		p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IOptpartitionspecContext is an interface to support dynamic dispatch.
type IOptpartitionspecContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Partitionspec() IPartitionspecContext

	// IsOptpartitionspecContext differentiates from other interfaces.
	IsOptpartitionspecContext()
}

type OptpartitionspecContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyOptpartitionspecContext() *OptpartitionspecContext {
	var p = new(OptpartitionspecContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_optpartitionspec
	return p
}

func InitEmptyOptpartitionspecContext(p *OptpartitionspecContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_optpartitionspec
}

func (*OptpartitionspecContext) IsOptpartitionspecContext() {}

func NewOptpartitionspecContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *OptpartitionspecContext {
	var p = new(OptpartitionspecContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_optpartitionspec

	return p
}

func (s *OptpartitionspecContext) GetParser() antlr.Parser { return s.parser }

func (s *OptpartitionspecContext) Partitionspec() IPartitionspecContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IPartitionspecContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IPartitionspecContext)
}

func (s *OptpartitionspecContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *OptpartitionspecContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *OptpartitionspecContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterOptpartitionspec(s)
	}
}

func (s *OptpartitionspecContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitOptpartitionspec(s)
	}
}

func (s *OptpartitionspecContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitOptpartitionspec(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Optpartitionspec() (localctx IOptpartitionspecContext) {
	localctx = NewOptpartitionspecContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 240, PostgreSQLParserRULE_optpartitionspec)
	p.SetState(3095)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetTokenStream().LA(1) {
	case PostgreSQLParserPARTITION:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(3093)
			p.Partitionspec()
		}

	case PostgreSQLParserEOF, PostgreSQLParserOPEN_PAREN, PostgreSQLParserSEMI, PostgreSQLParserANALYSE, PostgreSQLParserANALYZE, PostgreSQLParserCREATE, PostgreSQLParserDO, PostgreSQLParserFETCH, PostgreSQLParserGRANT, PostgreSQLParserINTO, PostgreSQLParserON, PostgreSQLParserSELECT, PostgreSQLParserTABLE, PostgreSQLParserUSING, PostgreSQLParserWITH, PostgreSQLParserABORT_P, PostgreSQLParserALTER, PostgreSQLParserBEGIN_P, PostgreSQLParserCHECKPOINT, PostgreSQLParserCLOSE, PostgreSQLParserCLUSTER, PostgreSQLParserCOMMENT, PostgreSQLParserCOMMIT, PostgreSQLParserCOPY, PostgreSQLParserDEALLOCATE, PostgreSQLParserDECLARE, PostgreSQLParserDELETE_P, PostgreSQLParserDISCARD, PostgreSQLParserDROP, PostgreSQLParserEXECUTE, PostgreSQLParserEXPLAIN, PostgreSQLParserINSERT, PostgreSQLParserLISTEN, PostgreSQLParserLOAD, PostgreSQLParserLOCK_P, PostgreSQLParserMERGE, PostgreSQLParserMOVE, PostgreSQLParserNOTIFY, PostgreSQLParserPREPARE, PostgreSQLParserREASSIGN, PostgreSQLParserREFRESH, PostgreSQLParserREINDEX, PostgreSQLParserRELEASE, PostgreSQLParserRESET, PostgreSQLParserREVOKE, PostgreSQLParserROLLBACK, PostgreSQLParserSAVEPOINT, PostgreSQLParserSECURITY, PostgreSQLParserSET, PostgreSQLParserSHOW, PostgreSQLParserSTART, PostgreSQLParserTABLESPACE, PostgreSQLParserTRUNCATE, PostgreSQLParserUNLISTEN, PostgreSQLParserUPDATE, PostgreSQLParserVACUUM, PostgreSQLParserWITHOUT, PostgreSQLParserVALUES, PostgreSQLParserCALL, PostgreSQLParserIMPORT_P, PostgreSQLParserEND_P, PostgreSQLParserMetaCommand:
		p.EnterOuterAlt(localctx, 2)

	default:
		p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IPartitionspecContext is an interface to support dynamic dispatch.
type IPartitionspecContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	PARTITION() antlr.TerminalNode
	BY() antlr.TerminalNode
	Colid() IColidContext
	OPEN_PAREN() antlr.TerminalNode
	Part_params() IPart_paramsContext
	CLOSE_PAREN() antlr.TerminalNode

	// IsPartitionspecContext differentiates from other interfaces.
	IsPartitionspecContext()
}

type PartitionspecContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyPartitionspecContext() *PartitionspecContext {
	var p = new(PartitionspecContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_partitionspec
	return p
}

func InitEmptyPartitionspecContext(p *PartitionspecContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_partitionspec
}

func (*PartitionspecContext) IsPartitionspecContext() {}

func NewPartitionspecContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *PartitionspecContext {
	var p = new(PartitionspecContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_partitionspec

	return p
}

func (s *PartitionspecContext) GetParser() antlr.Parser { return s.parser }

func (s *PartitionspecContext) PARTITION() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserPARTITION, 0)
}

func (s *PartitionspecContext) BY() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserBY, 0)
}

func (s *PartitionspecContext) Colid() IColidContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IColidContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IColidContext)
}

func (s *PartitionspecContext) OPEN_PAREN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserOPEN_PAREN, 0)
}

func (s *PartitionspecContext) Part_params() IPart_paramsContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IPart_paramsContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IPart_paramsContext)
}

func (s *PartitionspecContext) CLOSE_PAREN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCLOSE_PAREN, 0)
}

func (s *PartitionspecContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *PartitionspecContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *PartitionspecContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterPartitionspec(s)
	}
}

func (s *PartitionspecContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitPartitionspec(s)
	}
}

func (s *PartitionspecContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitPartitionspec(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Partitionspec() (localctx IPartitionspecContext) {
	localctx = NewPartitionspecContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 242, PostgreSQLParserRULE_partitionspec)
	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(3097)
		p.Match(PostgreSQLParserPARTITION)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(3098)
		p.Match(PostgreSQLParserBY)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(3099)
		p.Colid()
	}
	{
		p.SetState(3100)
		p.Match(PostgreSQLParserOPEN_PAREN)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(3101)
		p.Part_params()
	}
	{
		p.SetState(3102)
		p.Match(PostgreSQLParserCLOSE_PAREN)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IPart_paramsContext is an interface to support dynamic dispatch.
type IPart_paramsContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	AllPart_elem() []IPart_elemContext
	Part_elem(i int) IPart_elemContext
	AllCOMMA() []antlr.TerminalNode
	COMMA(i int) antlr.TerminalNode

	// IsPart_paramsContext differentiates from other interfaces.
	IsPart_paramsContext()
}

type Part_paramsContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyPart_paramsContext() *Part_paramsContext {
	var p = new(Part_paramsContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_part_params
	return p
}

func InitEmptyPart_paramsContext(p *Part_paramsContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_part_params
}

func (*Part_paramsContext) IsPart_paramsContext() {}

func NewPart_paramsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Part_paramsContext {
	var p = new(Part_paramsContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_part_params

	return p
}

func (s *Part_paramsContext) GetParser() antlr.Parser { return s.parser }

func (s *Part_paramsContext) AllPart_elem() []IPart_elemContext {
	children := s.GetChildren()
	len := 0
	for _, ctx := range children {
		if _, ok := ctx.(IPart_elemContext); ok {
			len++
		}
	}

	tst := make([]IPart_elemContext, len)
	i := 0
	for _, ctx := range children {
		if t, ok := ctx.(IPart_elemContext); ok {
			tst[i] = t.(IPart_elemContext)
			i++
		}
	}

	return tst
}

func (s *Part_paramsContext) Part_elem(i int) IPart_elemContext {
	var t antlr.RuleContext
	j := 0
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IPart_elemContext); ok {
			if j == i {
				t = ctx.(antlr.RuleContext)
				break
			}
			j++
		}
	}

	if t == nil {
		return nil
	}

	return t.(IPart_elemContext)
}

func (s *Part_paramsContext) AllCOMMA() []antlr.TerminalNode {
	return s.GetTokens(PostgreSQLParserCOMMA)
}

func (s *Part_paramsContext) COMMA(i int) antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCOMMA, i)
}

func (s *Part_paramsContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Part_paramsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Part_paramsContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterPart_params(s)
	}
}

func (s *Part_paramsContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitPart_params(s)
	}
}

func (s *Part_paramsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitPart_params(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Part_params() (localctx IPart_paramsContext) {
	localctx = NewPart_paramsContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 244, PostgreSQLParserRULE_part_params)
	var _la int

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(3104)
		p.Part_elem()
	}
	p.SetState(3109)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}
	_la = p.GetTokenStream().LA(1)

	for _la == PostgreSQLParserCOMMA {
		{
			p.SetState(3105)
			p.Match(PostgreSQLParserCOMMA)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(3106)
			p.Part_elem()
		}

		p.SetState(3111)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}
		_la = p.GetTokenStream().LA(1)
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IPart_elemContext is an interface to support dynamic dispatch.
type IPart_elemContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Colid() IColidContext
	Opt_collate() IOpt_collateContext
	Opt_class() IOpt_classContext
	Func_expr_windowless() IFunc_expr_windowlessContext
	OPEN_PAREN() antlr.TerminalNode
	A_expr() IA_exprContext
	CLOSE_PAREN() antlr.TerminalNode

	// IsPart_elemContext differentiates from other interfaces.
	IsPart_elemContext()
}

type Part_elemContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyPart_elemContext() *Part_elemContext {
	var p = new(Part_elemContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_part_elem
	return p
}

func InitEmptyPart_elemContext(p *Part_elemContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_part_elem
}

func (*Part_elemContext) IsPart_elemContext() {}

func NewPart_elemContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Part_elemContext {
	var p = new(Part_elemContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_part_elem

	return p
}

func (s *Part_elemContext) GetParser() antlr.Parser { return s.parser }

func (s *Part_elemContext) Colid() IColidContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IColidContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IColidContext)
}

func (s *Part_elemContext) Opt_collate() IOpt_collateContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOpt_collateContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOpt_collateContext)
}

func (s *Part_elemContext) Opt_class() IOpt_classContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOpt_classContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOpt_classContext)
}

func (s *Part_elemContext) Func_expr_windowless() IFunc_expr_windowlessContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IFunc_expr_windowlessContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IFunc_expr_windowlessContext)
}

func (s *Part_elemContext) OPEN_PAREN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserOPEN_PAREN, 0)
}

func (s *Part_elemContext) A_expr() IA_exprContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IA_exprContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IA_exprContext)
}

func (s *Part_elemContext) CLOSE_PAREN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCLOSE_PAREN, 0)
}

func (s *Part_elemContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Part_elemContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Part_elemContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterPart_elem(s)
	}
}

func (s *Part_elemContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitPart_elem(s)
	}
}

func (s *Part_elemContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitPart_elem(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Part_elem() (localctx IPart_elemContext) {
	localctx = NewPart_elemContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 246, PostgreSQLParserRULE_part_elem)
	p.SetState(3126)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 115, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(3112)
			p.Colid()
		}
		{
			p.SetState(3113)
			p.Opt_collate()
		}
		{
			p.SetState(3114)
			p.Opt_class()
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(3116)
			p.Func_expr_windowless()
		}
		{
			p.SetState(3117)
			p.Opt_collate()
		}
		{
			p.SetState(3118)
			p.Opt_class()
		}

	case 3:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(3120)
			p.Match(PostgreSQLParserOPEN_PAREN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(3121)
			p.A_expr()
		}
		{
			p.SetState(3122)
			p.Match(PostgreSQLParserCLOSE_PAREN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(3123)
			p.Opt_collate()
		}
		{
			p.SetState(3124)
			p.Opt_class()
		}

	case antlr.ATNInvalidAltNumber:
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// ITable_access_method_clauseContext is an interface to support dynamic dispatch.
type ITable_access_method_clauseContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	USING() antlr.TerminalNode
	Name() INameContext

	// IsTable_access_method_clauseContext differentiates from other interfaces.
	IsTable_access_method_clauseContext()
}

type Table_access_method_clauseContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyTable_access_method_clauseContext() *Table_access_method_clauseContext {
	var p = new(Table_access_method_clauseContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_table_access_method_clause
	return p
}

func InitEmptyTable_access_method_clauseContext(p *Table_access_method_clauseContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_table_access_method_clause
}

func (*Table_access_method_clauseContext) IsTable_access_method_clauseContext() {}

func NewTable_access_method_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Table_access_method_clauseContext {
	var p = new(Table_access_method_clauseContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_table_access_method_clause

	return p
}

func (s *Table_access_method_clauseContext) GetParser() antlr.Parser { return s.parser }

func (s *Table_access_method_clauseContext) USING() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserUSING, 0)
}

func (s *Table_access_method_clauseContext) Name() INameContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(INameContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(INameContext)
}

func (s *Table_access_method_clauseContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Table_access_method_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Table_access_method_clauseContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterTable_access_method_clause(s)
	}
}

func (s *Table_access_method_clauseContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitTable_access_method_clause(s)
	}
}

func (s *Table_access_method_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitTable_access_method_clause(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Table_access_method_clause() (localctx ITable_access_method_clauseContext) {
	localctx = NewTable_access_method_clauseContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 248, PostgreSQLParserRULE_table_access_method_clause)
	p.SetState(3131)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetTokenStream().LA(1) {
	case PostgreSQLParserUSING:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(3128)
			p.Match(PostgreSQLParserUSING)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(3129)
			p.Name()
		}

	case PostgreSQLParserEOF, PostgreSQLParserOPEN_PAREN, PostgreSQLParserSEMI, PostgreSQLParserANALYSE, PostgreSQLParserANALYZE, PostgreSQLParserAS, PostgreSQLParserCREATE, PostgreSQLParserDO, PostgreSQLParserFETCH, PostgreSQLParserGRANT, PostgreSQLParserINTO, PostgreSQLParserON, PostgreSQLParserSELECT, PostgreSQLParserTABLE, PostgreSQLParserWITH, PostgreSQLParserABORT_P, PostgreSQLParserALTER, PostgreSQLParserBEGIN_P, PostgreSQLParserCHECKPOINT, PostgreSQLParserCLOSE, PostgreSQLParserCLUSTER, PostgreSQLParserCOMMENT, PostgreSQLParserCOMMIT, PostgreSQLParserCOPY, PostgreSQLParserDEALLOCATE, PostgreSQLParserDECLARE, PostgreSQLParserDELETE_P, PostgreSQLParserDISCARD, PostgreSQLParserDROP, PostgreSQLParserEXECUTE, PostgreSQLParserEXPLAIN, PostgreSQLParserINSERT, PostgreSQLParserLISTEN, PostgreSQLParserLOAD, PostgreSQLParserLOCK_P, PostgreSQLParserMERGE, PostgreSQLParserMOVE, PostgreSQLParserNOTIFY, PostgreSQLParserPREPARE, PostgreSQLParserREASSIGN, PostgreSQLParserREFRESH, PostgreSQLParserREINDEX, PostgreSQLParserRELEASE, PostgreSQLParserRESET, PostgreSQLParserREVOKE, PostgreSQLParserROLLBACK, PostgreSQLParserSAVEPOINT, PostgreSQLParserSECURITY, PostgreSQLParserSET, PostgreSQLParserSHOW, PostgreSQLParserSTART, PostgreSQLParserTABLESPACE, PostgreSQLParserTRUNCATE, PostgreSQLParserUNLISTEN, PostgreSQLParserUPDATE, PostgreSQLParserVACUUM, PostgreSQLParserWITHOUT, PostgreSQLParserVALUES, PostgreSQLParserCALL, PostgreSQLParserIMPORT_P, PostgreSQLParserEND_P, PostgreSQLParserMetaCommand:
		p.EnterOuterAlt(localctx, 2)

	default:
		p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IOptwithContext is an interface to support dynamic dispatch.
type IOptwithContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	WITH() antlr.TerminalNode
	Reloptions() IReloptionsContext
	WITHOUT() antlr.TerminalNode
	OIDS() antlr.TerminalNode

	// IsOptwithContext differentiates from other interfaces.
	IsOptwithContext()
}

type OptwithContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyOptwithContext() *OptwithContext {
	var p = new(OptwithContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_optwith
	return p
}

func InitEmptyOptwithContext(p *OptwithContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_optwith
}

func (*OptwithContext) IsOptwithContext() {}

func NewOptwithContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *OptwithContext {
	var p = new(OptwithContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_optwith

	return p
}

func (s *OptwithContext) GetParser() antlr.Parser { return s.parser }

func (s *OptwithContext) WITH() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserWITH, 0)
}

func (s *OptwithContext) Reloptions() IReloptionsContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IReloptionsContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IReloptionsContext)
}

func (s *OptwithContext) WITHOUT() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserWITHOUT, 0)
}

func (s *OptwithContext) OIDS() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserOIDS, 0)
}

func (s *OptwithContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *OptwithContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *OptwithContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterOptwith(s)
	}
}

func (s *OptwithContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitOptwith(s)
	}
}

func (s *OptwithContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitOptwith(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Optwith() (localctx IOptwithContext) {
	localctx = NewOptwithContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 250, PostgreSQLParserRULE_optwith)
	p.SetState(3138)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 117, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(3133)
			p.Match(PostgreSQLParserWITH)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(3134)
			p.Reloptions()
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(3135)
			p.Match(PostgreSQLParserWITHOUT)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(3136)
			p.Match(PostgreSQLParserOIDS)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 3:
		p.EnterOuterAlt(localctx, 3)

	case antlr.ATNInvalidAltNumber:
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IOncommitoptionContext is an interface to support dynamic dispatch.
type IOncommitoptionContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	ON() antlr.TerminalNode
	COMMIT() antlr.TerminalNode
	DROP() antlr.TerminalNode
	DELETE_P() antlr.TerminalNode
	ROWS() antlr.TerminalNode
	PRESERVE() antlr.TerminalNode

	// IsOncommitoptionContext differentiates from other interfaces.
	IsOncommitoptionContext()
}

type OncommitoptionContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyOncommitoptionContext() *OncommitoptionContext {
	var p = new(OncommitoptionContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_oncommitoption
	return p
}

func InitEmptyOncommitoptionContext(p *OncommitoptionContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_oncommitoption
}

func (*OncommitoptionContext) IsOncommitoptionContext() {}

func NewOncommitoptionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *OncommitoptionContext {
	var p = new(OncommitoptionContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_oncommitoption

	return p
}

func (s *OncommitoptionContext) GetParser() antlr.Parser { return s.parser }

func (s *OncommitoptionContext) ON() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserON, 0)
}

func (s *OncommitoptionContext) COMMIT() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCOMMIT, 0)
}

func (s *OncommitoptionContext) DROP() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserDROP, 0)
}

func (s *OncommitoptionContext) DELETE_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserDELETE_P, 0)
}

func (s *OncommitoptionContext) ROWS() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserROWS, 0)
}

func (s *OncommitoptionContext) PRESERVE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserPRESERVE, 0)
}

func (s *OncommitoptionContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *OncommitoptionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *OncommitoptionContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterOncommitoption(s)
	}
}

func (s *OncommitoptionContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitOncommitoption(s)
	}
}

func (s *OncommitoptionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitOncommitoption(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Oncommitoption() (localctx IOncommitoptionContext) {
	localctx = NewOncommitoptionContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 252, PostgreSQLParserRULE_oncommitoption)
	p.SetState(3150)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetTokenStream().LA(1) {
	case PostgreSQLParserON:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(3140)
			p.Match(PostgreSQLParserON)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(3141)
			p.Match(PostgreSQLParserCOMMIT)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		p.SetState(3147)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}

		switch p.GetTokenStream().LA(1) {
		case PostgreSQLParserDROP:
			{
				p.SetState(3142)
				p.Match(PostgreSQLParserDROP)
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}

		case PostgreSQLParserDELETE_P:
			{
				p.SetState(3143)
				p.Match(PostgreSQLParserDELETE_P)
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}
			{
				p.SetState(3144)
				p.Match(PostgreSQLParserROWS)
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}

		case PostgreSQLParserPRESERVE:
			{
				p.SetState(3145)
				p.Match(PostgreSQLParserPRESERVE)
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}
			{
				p.SetState(3146)
				p.Match(PostgreSQLParserROWS)
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}

		default:
			p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
			goto errorExit
		}

	case PostgreSQLParserEOF, PostgreSQLParserOPEN_PAREN, PostgreSQLParserSEMI, PostgreSQLParserANALYSE, PostgreSQLParserANALYZE, PostgreSQLParserAS, PostgreSQLParserCREATE, PostgreSQLParserDO, PostgreSQLParserFETCH, PostgreSQLParserGRANT, PostgreSQLParserINTO, PostgreSQLParserSELECT, PostgreSQLParserTABLE, PostgreSQLParserWITH, PostgreSQLParserABORT_P, PostgreSQLParserALTER, PostgreSQLParserBEGIN_P, PostgreSQLParserCHECKPOINT, PostgreSQLParserCLOSE, PostgreSQLParserCLUSTER, PostgreSQLParserCOMMENT, PostgreSQLParserCOMMIT, PostgreSQLParserCOPY, PostgreSQLParserDEALLOCATE, PostgreSQLParserDECLARE, PostgreSQLParserDELETE_P, PostgreSQLParserDISCARD, PostgreSQLParserDROP, PostgreSQLParserEXECUTE, PostgreSQLParserEXPLAIN, PostgreSQLParserINSERT, PostgreSQLParserLISTEN, PostgreSQLParserLOAD, PostgreSQLParserLOCK_P, PostgreSQLParserMERGE, PostgreSQLParserMOVE, PostgreSQLParserNOTIFY, PostgreSQLParserPREPARE, PostgreSQLParserREASSIGN, PostgreSQLParserREFRESH, PostgreSQLParserREINDEX, PostgreSQLParserRELEASE, PostgreSQLParserRESET, PostgreSQLParserREVOKE, PostgreSQLParserROLLBACK, PostgreSQLParserSAVEPOINT, PostgreSQLParserSECURITY, PostgreSQLParserSET, PostgreSQLParserSHOW, PostgreSQLParserSTART, PostgreSQLParserTABLESPACE, PostgreSQLParserTRUNCATE, PostgreSQLParserUNLISTEN, PostgreSQLParserUPDATE, PostgreSQLParserVACUUM, PostgreSQLParserVALUES, PostgreSQLParserCALL, PostgreSQLParserIMPORT_P, PostgreSQLParserEND_P, PostgreSQLParserMetaCommand:
		p.EnterOuterAlt(localctx, 2)

	default:
		p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IOpttablespaceContext is an interface to support dynamic dispatch.
type IOpttablespaceContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	TABLESPACE() antlr.TerminalNode
	Name() INameContext

	// IsOpttablespaceContext differentiates from other interfaces.
	IsOpttablespaceContext()
}

type OpttablespaceContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyOpttablespaceContext() *OpttablespaceContext {
	var p = new(OpttablespaceContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opttablespace
	return p
}

func InitEmptyOpttablespaceContext(p *OpttablespaceContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opttablespace
}

func (*OpttablespaceContext) IsOpttablespaceContext() {}

func NewOpttablespaceContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *OpttablespaceContext {
	var p = new(OpttablespaceContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_opttablespace

	return p
}

func (s *OpttablespaceContext) GetParser() antlr.Parser { return s.parser }

func (s *OpttablespaceContext) TABLESPACE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserTABLESPACE, 0)
}

func (s *OpttablespaceContext) Name() INameContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(INameContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(INameContext)
}

func (s *OpttablespaceContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *OpttablespaceContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *OpttablespaceContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterOpttablespace(s)
	}
}

func (s *OpttablespaceContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitOpttablespace(s)
	}
}

func (s *OpttablespaceContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitOpttablespace(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Opttablespace() (localctx IOpttablespaceContext) {
	localctx = NewOpttablespaceContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 254, PostgreSQLParserRULE_opttablespace)
	p.SetState(3155)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetTokenStream().LA(1) {
	case PostgreSQLParserTABLESPACE:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(3152)
			p.Match(PostgreSQLParserTABLESPACE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(3153)
			p.Name()
		}

	case PostgreSQLParserEOF, PostgreSQLParserOPEN_PAREN, PostgreSQLParserSEMI, PostgreSQLParserANALYSE, PostgreSQLParserANALYZE, PostgreSQLParserAS, PostgreSQLParserCREATE, PostgreSQLParserDO, PostgreSQLParserFETCH, PostgreSQLParserGRANT, PostgreSQLParserINTO, PostgreSQLParserSELECT, PostgreSQLParserTABLE, PostgreSQLParserWHERE, PostgreSQLParserWITH, PostgreSQLParserABORT_P, PostgreSQLParserALTER, PostgreSQLParserBEGIN_P, PostgreSQLParserCHECKPOINT, PostgreSQLParserCLOSE, PostgreSQLParserCLUSTER, PostgreSQLParserCOMMENT, PostgreSQLParserCOMMIT, PostgreSQLParserCOPY, PostgreSQLParserDEALLOCATE, PostgreSQLParserDECLARE, PostgreSQLParserDELETE_P, PostgreSQLParserDISCARD, PostgreSQLParserDROP, PostgreSQLParserEXECUTE, PostgreSQLParserEXPLAIN, PostgreSQLParserINSERT, PostgreSQLParserLISTEN, PostgreSQLParserLOAD, PostgreSQLParserLOCK_P, PostgreSQLParserMERGE, PostgreSQLParserMOVE, PostgreSQLParserNOTIFY, PostgreSQLParserPREPARE, PostgreSQLParserREASSIGN, PostgreSQLParserREFRESH, PostgreSQLParserREINDEX, PostgreSQLParserRELEASE, PostgreSQLParserRESET, PostgreSQLParserREVOKE, PostgreSQLParserROLLBACK, PostgreSQLParserSAVEPOINT, PostgreSQLParserSECURITY, PostgreSQLParserSET, PostgreSQLParserSHOW, PostgreSQLParserSTART, PostgreSQLParserTRUNCATE, PostgreSQLParserUNLISTEN, PostgreSQLParserUPDATE, PostgreSQLParserVACUUM, PostgreSQLParserVALUES, PostgreSQLParserCALL, PostgreSQLParserIMPORT_P, PostgreSQLParserEND_P, PostgreSQLParserMetaCommand:
		p.EnterOuterAlt(localctx, 2)

	default:
		p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IOptconstablespaceContext is an interface to support dynamic dispatch.
type IOptconstablespaceContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	USING() antlr.TerminalNode
	INDEX() antlr.TerminalNode
	TABLESPACE() antlr.TerminalNode
	Name() INameContext

	// IsOptconstablespaceContext differentiates from other interfaces.
	IsOptconstablespaceContext()
}

type OptconstablespaceContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyOptconstablespaceContext() *OptconstablespaceContext {
	var p = new(OptconstablespaceContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_optconstablespace
	return p
}

func InitEmptyOptconstablespaceContext(p *OptconstablespaceContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_optconstablespace
}

func (*OptconstablespaceContext) IsOptconstablespaceContext() {}

func NewOptconstablespaceContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *OptconstablespaceContext {
	var p = new(OptconstablespaceContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_optconstablespace

	return p
}

func (s *OptconstablespaceContext) GetParser() antlr.Parser { return s.parser }

func (s *OptconstablespaceContext) USING() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserUSING, 0)
}

func (s *OptconstablespaceContext) INDEX() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserINDEX, 0)
}

func (s *OptconstablespaceContext) TABLESPACE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserTABLESPACE, 0)
}

func (s *OptconstablespaceContext) Name() INameContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(INameContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(INameContext)
}

func (s *OptconstablespaceContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *OptconstablespaceContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *OptconstablespaceContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterOptconstablespace(s)
	}
}

func (s *OptconstablespaceContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitOptconstablespace(s)
	}
}

func (s *OptconstablespaceContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitOptconstablespace(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Optconstablespace() (localctx IOptconstablespaceContext) {
	localctx = NewOptconstablespaceContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 256, PostgreSQLParserRULE_optconstablespace)
	p.SetState(3162)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetTokenStream().LA(1) {
	case PostgreSQLParserUSING:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(3157)
			p.Match(PostgreSQLParserUSING)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(3158)
			p.Match(PostgreSQLParserINDEX)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(3159)
			p.Match(PostgreSQLParserTABLESPACE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(3160)
			p.Name()
		}

	case PostgreSQLParserEOF, PostgreSQLParserOPEN_PAREN, PostgreSQLParserCLOSE_PAREN, PostgreSQLParserCOMMA, PostgreSQLParserSEMI, PostgreSQLParserANALYSE, PostgreSQLParserANALYZE, PostgreSQLParserCHECK, PostgreSQLParserCOLLATE, PostgreSQLParserCONSTRAINT, PostgreSQLParserCREATE, PostgreSQLParserDEFAULT, PostgreSQLParserDEFERRABLE, PostgreSQLParserDO, PostgreSQLParserFETCH, PostgreSQLParserGRANT, PostgreSQLParserINITIALLY, PostgreSQLParserINTO, PostgreSQLParserNOT, PostgreSQLParserNULL_P, PostgreSQLParserPRIMARY, PostgreSQLParserREFERENCES, PostgreSQLParserSELECT, PostgreSQLParserTABLE, PostgreSQLParserUNIQUE, PostgreSQLParserWHERE, PostgreSQLParserWITH, PostgreSQLParserABORT_P, PostgreSQLParserALTER, PostgreSQLParserBEGIN_P, PostgreSQLParserCHECKPOINT, PostgreSQLParserCLOSE, PostgreSQLParserCLUSTER, PostgreSQLParserCOMMENT, PostgreSQLParserCOMMIT, PostgreSQLParserCOPY, PostgreSQLParserDEALLOCATE, PostgreSQLParserDECLARE, PostgreSQLParserDELETE_P, PostgreSQLParserDISCARD, PostgreSQLParserDROP, PostgreSQLParserEXECUTE, PostgreSQLParserEXPLAIN, PostgreSQLParserINSERT, PostgreSQLParserLISTEN, PostgreSQLParserLOAD, PostgreSQLParserLOCK_P, PostgreSQLParserMERGE, PostgreSQLParserMOVE, PostgreSQLParserNO, PostgreSQLParserNOTIFY, PostgreSQLParserPREPARE, PostgreSQLParserREASSIGN, PostgreSQLParserREFRESH, PostgreSQLParserREINDEX, PostgreSQLParserRELEASE, PostgreSQLParserRESET, PostgreSQLParserREVOKE, PostgreSQLParserROLLBACK, PostgreSQLParserSAVEPOINT, PostgreSQLParserSECURITY, PostgreSQLParserSET, PostgreSQLParserSHOW, PostgreSQLParserSTART, PostgreSQLParserTRUNCATE, PostgreSQLParserUNLISTEN, PostgreSQLParserUPDATE, PostgreSQLParserVACUUM, PostgreSQLParserVALUES, PostgreSQLParserCALL, PostgreSQLParserGENERATED, PostgreSQLParserIMPORT_P, PostgreSQLParserEND_P, PostgreSQLParserMetaCommand:
		p.EnterOuterAlt(localctx, 2)

	default:
		p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IExistingindexContext is an interface to support dynamic dispatch.
type IExistingindexContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	USING() antlr.TerminalNode
	INDEX() antlr.TerminalNode
	Name() INameContext

	// IsExistingindexContext differentiates from other interfaces.
	IsExistingindexContext()
}

type ExistingindexContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyExistingindexContext() *ExistingindexContext {
	var p = new(ExistingindexContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_existingindex
	return p
}

func InitEmptyExistingindexContext(p *ExistingindexContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_existingindex
}

func (*ExistingindexContext) IsExistingindexContext() {}

func NewExistingindexContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ExistingindexContext {
	var p = new(ExistingindexContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_existingindex

	return p
}

func (s *ExistingindexContext) GetParser() antlr.Parser { return s.parser }

func (s *ExistingindexContext) USING() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserUSING, 0)
}

func (s *ExistingindexContext) INDEX() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserINDEX, 0)
}

func (s *ExistingindexContext) Name() INameContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(INameContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(INameContext)
}

func (s *ExistingindexContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *ExistingindexContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *ExistingindexContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterExistingindex(s)
	}
}

func (s *ExistingindexContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitExistingindex(s)
	}
}

func (s *ExistingindexContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitExistingindex(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Existingindex() (localctx IExistingindexContext) {
	localctx = NewExistingindexContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 258, PostgreSQLParserRULE_existingindex)
	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(3164)
		p.Match(PostgreSQLParserUSING)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(3165)
		p.Match(PostgreSQLParserINDEX)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(3166)
		p.Name()
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// ICreatestatsstmtContext is an interface to support dynamic dispatch.
type ICreatestatsstmtContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	CREATE() antlr.TerminalNode
	STATISTICS() antlr.TerminalNode
	Any_name() IAny_nameContext
	Opt_name_list() IOpt_name_listContext
	ON() antlr.TerminalNode
	Expr_list() IExpr_listContext
	FROM() antlr.TerminalNode
	From_list() IFrom_listContext
	IF_P() antlr.TerminalNode
	NOT() antlr.TerminalNode
	EXISTS() antlr.TerminalNode

	// IsCreatestatsstmtContext differentiates from other interfaces.
	IsCreatestatsstmtContext()
}

type CreatestatsstmtContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyCreatestatsstmtContext() *CreatestatsstmtContext {
	var p = new(CreatestatsstmtContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_createstatsstmt
	return p
}

func InitEmptyCreatestatsstmtContext(p *CreatestatsstmtContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_createstatsstmt
}

func (*CreatestatsstmtContext) IsCreatestatsstmtContext() {}

func NewCreatestatsstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CreatestatsstmtContext {
	var p = new(CreatestatsstmtContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_createstatsstmt

	return p
}

func (s *CreatestatsstmtContext) GetParser() antlr.Parser { return s.parser }

func (s *CreatestatsstmtContext) CREATE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCREATE, 0)
}

func (s *CreatestatsstmtContext) STATISTICS() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserSTATISTICS, 0)
}

func (s *CreatestatsstmtContext) Any_name() IAny_nameContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IAny_nameContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IAny_nameContext)
}

func (s *CreatestatsstmtContext) Opt_name_list() IOpt_name_listContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOpt_name_listContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOpt_name_listContext)
}

func (s *CreatestatsstmtContext) ON() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserON, 0)
}

func (s *CreatestatsstmtContext) Expr_list() IExpr_listContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IExpr_listContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IExpr_listContext)
}

func (s *CreatestatsstmtContext) FROM() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserFROM, 0)
}

func (s *CreatestatsstmtContext) From_list() IFrom_listContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IFrom_listContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IFrom_listContext)
}

func (s *CreatestatsstmtContext) IF_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserIF_P, 0)
}

func (s *CreatestatsstmtContext) NOT() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserNOT, 0)
}

func (s *CreatestatsstmtContext) EXISTS() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserEXISTS, 0)
}

func (s *CreatestatsstmtContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *CreatestatsstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *CreatestatsstmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterCreatestatsstmt(s)
	}
}

func (s *CreatestatsstmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitCreatestatsstmt(s)
	}
}

func (s *CreatestatsstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitCreatestatsstmt(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Createstatsstmt() (localctx ICreatestatsstmtContext) {
	localctx = NewCreatestatsstmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 260, PostgreSQLParserRULE_createstatsstmt)
	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(3168)
		p.Match(PostgreSQLParserCREATE)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(3169)
		p.Match(PostgreSQLParserSTATISTICS)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	p.SetState(3173)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 122, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(3170)
			p.Match(PostgreSQLParserIF_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(3171)
			p.Match(PostgreSQLParserNOT)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(3172)
			p.Match(PostgreSQLParserEXISTS)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	} else if p.HasError() { // JIM
		goto errorExit
	}
	{
		p.SetState(3175)
		p.Any_name()
	}
	{
		p.SetState(3176)
		p.Opt_name_list()
	}
	{
		p.SetState(3177)
		p.Match(PostgreSQLParserON)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(3178)
		p.Expr_list()
	}
	{
		p.SetState(3179)
		p.Match(PostgreSQLParserFROM)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(3180)
		p.From_list()
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IAlterstatsstmtContext is an interface to support dynamic dispatch.
type IAlterstatsstmtContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	ALTER() antlr.TerminalNode
	AllSTATISTICS() []antlr.TerminalNode
	STATISTICS(i int) antlr.TerminalNode
	Any_name() IAny_nameContext
	SET() antlr.TerminalNode
	Signediconst() ISignediconstContext
	IF_P() antlr.TerminalNode
	EXISTS() antlr.TerminalNode

	// IsAlterstatsstmtContext differentiates from other interfaces.
	IsAlterstatsstmtContext()
}

type AlterstatsstmtContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyAlterstatsstmtContext() *AlterstatsstmtContext {
	var p = new(AlterstatsstmtContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_alterstatsstmt
	return p
}

func InitEmptyAlterstatsstmtContext(p *AlterstatsstmtContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_alterstatsstmt
}

func (*AlterstatsstmtContext) IsAlterstatsstmtContext() {}

func NewAlterstatsstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AlterstatsstmtContext {
	var p = new(AlterstatsstmtContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_alterstatsstmt

	return p
}

func (s *AlterstatsstmtContext) GetParser() antlr.Parser { return s.parser }

func (s *AlterstatsstmtContext) ALTER() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserALTER, 0)
}

func (s *AlterstatsstmtContext) AllSTATISTICS() []antlr.TerminalNode {
	return s.GetTokens(PostgreSQLParserSTATISTICS)
}

func (s *AlterstatsstmtContext) STATISTICS(i int) antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserSTATISTICS, i)
}

func (s *AlterstatsstmtContext) Any_name() IAny_nameContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IAny_nameContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IAny_nameContext)
}

func (s *AlterstatsstmtContext) SET() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserSET, 0)
}

func (s *AlterstatsstmtContext) Signediconst() ISignediconstContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ISignediconstContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ISignediconstContext)
}

func (s *AlterstatsstmtContext) IF_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserIF_P, 0)
}

func (s *AlterstatsstmtContext) EXISTS() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserEXISTS, 0)
}

func (s *AlterstatsstmtContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *AlterstatsstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *AlterstatsstmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterAlterstatsstmt(s)
	}
}

func (s *AlterstatsstmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitAlterstatsstmt(s)
	}
}

func (s *AlterstatsstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitAlterstatsstmt(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Alterstatsstmt() (localctx IAlterstatsstmtContext) {
	localctx = NewAlterstatsstmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 262, PostgreSQLParserRULE_alterstatsstmt)
	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(3182)
		p.Match(PostgreSQLParserALTER)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(3183)
		p.Match(PostgreSQLParserSTATISTICS)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	p.SetState(3186)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 123, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(3184)
			p.Match(PostgreSQLParserIF_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(3185)
			p.Match(PostgreSQLParserEXISTS)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	} else if p.HasError() { // JIM
		goto errorExit
	}
	{
		p.SetState(3188)
		p.Any_name()
	}
	{
		p.SetState(3189)
		p.Match(PostgreSQLParserSET)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(3190)
		p.Match(PostgreSQLParserSTATISTICS)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(3191)
		p.Signediconst()
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// ICreateasstmtContext is an interface to support dynamic dispatch.
type ICreateasstmtContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	CREATE() antlr.TerminalNode
	Opttemp() IOpttempContext
	TABLE() antlr.TerminalNode
	Create_as_target() ICreate_as_targetContext
	AS() antlr.TerminalNode
	Selectstmt() ISelectstmtContext
	Opt_with_data() IOpt_with_dataContext
	IF_P() antlr.TerminalNode
	NOT() antlr.TerminalNode
	EXISTS() antlr.TerminalNode

	// IsCreateasstmtContext differentiates from other interfaces.
	IsCreateasstmtContext()
}

type CreateasstmtContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyCreateasstmtContext() *CreateasstmtContext {
	var p = new(CreateasstmtContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_createasstmt
	return p
}

func InitEmptyCreateasstmtContext(p *CreateasstmtContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_createasstmt
}

func (*CreateasstmtContext) IsCreateasstmtContext() {}

func NewCreateasstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CreateasstmtContext {
	var p = new(CreateasstmtContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_createasstmt

	return p
}

func (s *CreateasstmtContext) GetParser() antlr.Parser { return s.parser }

func (s *CreateasstmtContext) CREATE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCREATE, 0)
}

func (s *CreateasstmtContext) Opttemp() IOpttempContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOpttempContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOpttempContext)
}

func (s *CreateasstmtContext) TABLE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserTABLE, 0)
}

func (s *CreateasstmtContext) Create_as_target() ICreate_as_targetContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ICreate_as_targetContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ICreate_as_targetContext)
}

func (s *CreateasstmtContext) AS() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserAS, 0)
}

func (s *CreateasstmtContext) Selectstmt() ISelectstmtContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ISelectstmtContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ISelectstmtContext)
}

func (s *CreateasstmtContext) Opt_with_data() IOpt_with_dataContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOpt_with_dataContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOpt_with_dataContext)
}

func (s *CreateasstmtContext) IF_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserIF_P, 0)
}

func (s *CreateasstmtContext) NOT() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserNOT, 0)
}

func (s *CreateasstmtContext) EXISTS() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserEXISTS, 0)
}

func (s *CreateasstmtContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *CreateasstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *CreateasstmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterCreateasstmt(s)
	}
}

func (s *CreateasstmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitCreateasstmt(s)
	}
}

func (s *CreateasstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitCreateasstmt(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Createasstmt() (localctx ICreateasstmtContext) {
	localctx = NewCreateasstmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 264, PostgreSQLParserRULE_createasstmt)
	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(3193)
		p.Match(PostgreSQLParserCREATE)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(3194)
		p.Opttemp()
	}
	{
		p.SetState(3195)
		p.Match(PostgreSQLParserTABLE)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	p.SetState(3199)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 124, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(3196)
			p.Match(PostgreSQLParserIF_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(3197)
			p.Match(PostgreSQLParserNOT)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(3198)
			p.Match(PostgreSQLParserEXISTS)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	} else if p.HasError() { // JIM
		goto errorExit
	}
	{
		p.SetState(3201)
		p.Create_as_target()
	}
	{
		p.SetState(3202)
		p.Match(PostgreSQLParserAS)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(3203)
		p.Selectstmt()
	}
	{
		p.SetState(3204)
		p.Opt_with_data()
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// ICreate_as_targetContext is an interface to support dynamic dispatch.
type ICreate_as_targetContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Qualified_name() IQualified_nameContext
	Opt_column_list() IOpt_column_listContext
	Table_access_method_clause() ITable_access_method_clauseContext
	Optwith() IOptwithContext
	Oncommitoption() IOncommitoptionContext
	Opttablespace() IOpttablespaceContext

	// IsCreate_as_targetContext differentiates from other interfaces.
	IsCreate_as_targetContext()
}

type Create_as_targetContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyCreate_as_targetContext() *Create_as_targetContext {
	var p = new(Create_as_targetContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_create_as_target
	return p
}

func InitEmptyCreate_as_targetContext(p *Create_as_targetContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_create_as_target
}

func (*Create_as_targetContext) IsCreate_as_targetContext() {}

func NewCreate_as_targetContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_as_targetContext {
	var p = new(Create_as_targetContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_create_as_target

	return p
}

func (s *Create_as_targetContext) GetParser() antlr.Parser { return s.parser }

func (s *Create_as_targetContext) Qualified_name() IQualified_nameContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IQualified_nameContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IQualified_nameContext)
}

func (s *Create_as_targetContext) Opt_column_list() IOpt_column_listContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOpt_column_listContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOpt_column_listContext)
}

func (s *Create_as_targetContext) Table_access_method_clause() ITable_access_method_clauseContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ITable_access_method_clauseContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ITable_access_method_clauseContext)
}

func (s *Create_as_targetContext) Optwith() IOptwithContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOptwithContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOptwithContext)
}

func (s *Create_as_targetContext) Oncommitoption() IOncommitoptionContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOncommitoptionContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOncommitoptionContext)
}

func (s *Create_as_targetContext) Opttablespace() IOpttablespaceContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOpttablespaceContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOpttablespaceContext)
}

func (s *Create_as_targetContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Create_as_targetContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Create_as_targetContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterCreate_as_target(s)
	}
}

func (s *Create_as_targetContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitCreate_as_target(s)
	}
}

func (s *Create_as_targetContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitCreate_as_target(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Create_as_target() (localctx ICreate_as_targetContext) {
	localctx = NewCreate_as_targetContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 266, PostgreSQLParserRULE_create_as_target)
	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(3206)
		p.Qualified_name()
	}
	{
		p.SetState(3207)
		p.Opt_column_list()
	}
	{
		p.SetState(3208)
		p.Table_access_method_clause()
	}
	{
		p.SetState(3209)
		p.Optwith()
	}
	{
		p.SetState(3210)
		p.Oncommitoption()
	}
	{
		p.SetState(3211)
		p.Opttablespace()
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IOpt_with_dataContext is an interface to support dynamic dispatch.
type IOpt_with_dataContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	WITH() antlr.TerminalNode
	DATA_P() antlr.TerminalNode
	NO() antlr.TerminalNode

	// IsOpt_with_dataContext differentiates from other interfaces.
	IsOpt_with_dataContext()
}

type Opt_with_dataContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyOpt_with_dataContext() *Opt_with_dataContext {
	var p = new(Opt_with_dataContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opt_with_data
	return p
}

func InitEmptyOpt_with_dataContext(p *Opt_with_dataContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opt_with_data
}

func (*Opt_with_dataContext) IsOpt_with_dataContext() {}

func NewOpt_with_dataContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_with_dataContext {
	var p = new(Opt_with_dataContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_opt_with_data

	return p
}

func (s *Opt_with_dataContext) GetParser() antlr.Parser { return s.parser }

func (s *Opt_with_dataContext) WITH() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserWITH, 0)
}

func (s *Opt_with_dataContext) DATA_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserDATA_P, 0)
}

func (s *Opt_with_dataContext) NO() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserNO, 0)
}

func (s *Opt_with_dataContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Opt_with_dataContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Opt_with_dataContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterOpt_with_data(s)
	}
}

func (s *Opt_with_dataContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitOpt_with_data(s)
	}
}

func (s *Opt_with_dataContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitOpt_with_data(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Opt_with_data() (localctx IOpt_with_dataContext) {
	localctx = NewOpt_with_dataContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 268, PostgreSQLParserRULE_opt_with_data)
	p.SetState(3220)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 126, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(3213)
			p.Match(PostgreSQLParserWITH)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		p.SetState(3217)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}

		switch p.GetTokenStream().LA(1) {
		case PostgreSQLParserDATA_P:
			{
				p.SetState(3214)
				p.Match(PostgreSQLParserDATA_P)
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}

		case PostgreSQLParserNO:
			{
				p.SetState(3215)
				p.Match(PostgreSQLParserNO)
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}
			{
				p.SetState(3216)
				p.Match(PostgreSQLParserDATA_P)
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}

		default:
			p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
			goto errorExit
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)

	case antlr.ATNInvalidAltNumber:
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// ICreatematviewstmtContext is an interface to support dynamic dispatch.
type ICreatematviewstmtContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	CREATE() antlr.TerminalNode
	Optnolog() IOptnologContext
	MATERIALIZED() antlr.TerminalNode
	VIEW() antlr.TerminalNode
	Create_mv_target() ICreate_mv_targetContext
	AS() antlr.TerminalNode
	Selectstmt() ISelectstmtContext
	Opt_with_data() IOpt_with_dataContext
	IF_P() antlr.TerminalNode
	NOT() antlr.TerminalNode
	EXISTS() antlr.TerminalNode

	// IsCreatematviewstmtContext differentiates from other interfaces.
	IsCreatematviewstmtContext()
}

type CreatematviewstmtContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyCreatematviewstmtContext() *CreatematviewstmtContext {
	var p = new(CreatematviewstmtContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_creatematviewstmt
	return p
}

func InitEmptyCreatematviewstmtContext(p *CreatematviewstmtContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_creatematviewstmt
}

func (*CreatematviewstmtContext) IsCreatematviewstmtContext() {}

func NewCreatematviewstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CreatematviewstmtContext {
	var p = new(CreatematviewstmtContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_creatematviewstmt

	return p
}

func (s *CreatematviewstmtContext) GetParser() antlr.Parser { return s.parser }

func (s *CreatematviewstmtContext) CREATE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCREATE, 0)
}

func (s *CreatematviewstmtContext) Optnolog() IOptnologContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOptnologContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOptnologContext)
}

func (s *CreatematviewstmtContext) MATERIALIZED() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserMATERIALIZED, 0)
}

func (s *CreatematviewstmtContext) VIEW() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserVIEW, 0)
}

func (s *CreatematviewstmtContext) Create_mv_target() ICreate_mv_targetContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ICreate_mv_targetContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ICreate_mv_targetContext)
}

func (s *CreatematviewstmtContext) AS() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserAS, 0)
}

func (s *CreatematviewstmtContext) Selectstmt() ISelectstmtContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ISelectstmtContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ISelectstmtContext)
}

func (s *CreatematviewstmtContext) Opt_with_data() IOpt_with_dataContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOpt_with_dataContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOpt_with_dataContext)
}

func (s *CreatematviewstmtContext) IF_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserIF_P, 0)
}

func (s *CreatematviewstmtContext) NOT() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserNOT, 0)
}

func (s *CreatematviewstmtContext) EXISTS() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserEXISTS, 0)
}

func (s *CreatematviewstmtContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *CreatematviewstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *CreatematviewstmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterCreatematviewstmt(s)
	}
}

func (s *CreatematviewstmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitCreatematviewstmt(s)
	}
}

func (s *CreatematviewstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitCreatematviewstmt(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Creatematviewstmt() (localctx ICreatematviewstmtContext) {
	localctx = NewCreatematviewstmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 270, PostgreSQLParserRULE_creatematviewstmt)
	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(3222)
		p.Match(PostgreSQLParserCREATE)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(3223)
		p.Optnolog()
	}
	{
		p.SetState(3224)
		p.Match(PostgreSQLParserMATERIALIZED)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(3225)
		p.Match(PostgreSQLParserVIEW)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	p.SetState(3229)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 127, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(3226)
			p.Match(PostgreSQLParserIF_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(3227)
			p.Match(PostgreSQLParserNOT)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(3228)
			p.Match(PostgreSQLParserEXISTS)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	} else if p.HasError() { // JIM
		goto errorExit
	}
	{
		p.SetState(3231)
		p.Create_mv_target()
	}
	{
		p.SetState(3232)
		p.Match(PostgreSQLParserAS)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(3233)
		p.Selectstmt()
	}
	{
		p.SetState(3234)
		p.Opt_with_data()
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// ICreate_mv_targetContext is an interface to support dynamic dispatch.
type ICreate_mv_targetContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Qualified_name() IQualified_nameContext
	Opt_column_list() IOpt_column_listContext
	Table_access_method_clause() ITable_access_method_clauseContext
	Opt_reloptions() IOpt_reloptionsContext
	Opttablespace() IOpttablespaceContext

	// IsCreate_mv_targetContext differentiates from other interfaces.
	IsCreate_mv_targetContext()
}

type Create_mv_targetContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyCreate_mv_targetContext() *Create_mv_targetContext {
	var p = new(Create_mv_targetContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_create_mv_target
	return p
}

func InitEmptyCreate_mv_targetContext(p *Create_mv_targetContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_create_mv_target
}

func (*Create_mv_targetContext) IsCreate_mv_targetContext() {}

func NewCreate_mv_targetContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_mv_targetContext {
	var p = new(Create_mv_targetContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_create_mv_target

	return p
}

func (s *Create_mv_targetContext) GetParser() antlr.Parser { return s.parser }

func (s *Create_mv_targetContext) Qualified_name() IQualified_nameContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IQualified_nameContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IQualified_nameContext)
}

func (s *Create_mv_targetContext) Opt_column_list() IOpt_column_listContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOpt_column_listContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOpt_column_listContext)
}

func (s *Create_mv_targetContext) Table_access_method_clause() ITable_access_method_clauseContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ITable_access_method_clauseContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ITable_access_method_clauseContext)
}

func (s *Create_mv_targetContext) Opt_reloptions() IOpt_reloptionsContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOpt_reloptionsContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOpt_reloptionsContext)
}

func (s *Create_mv_targetContext) Opttablespace() IOpttablespaceContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOpttablespaceContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOpttablespaceContext)
}

func (s *Create_mv_targetContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Create_mv_targetContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Create_mv_targetContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterCreate_mv_target(s)
	}
}

func (s *Create_mv_targetContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitCreate_mv_target(s)
	}
}

func (s *Create_mv_targetContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitCreate_mv_target(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Create_mv_target() (localctx ICreate_mv_targetContext) {
	localctx = NewCreate_mv_targetContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 272, PostgreSQLParserRULE_create_mv_target)
	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(3236)
		p.Qualified_name()
	}
	{
		p.SetState(3237)
		p.Opt_column_list()
	}
	{
		p.SetState(3238)
		p.Table_access_method_clause()
	}
	{
		p.SetState(3239)
		p.Opt_reloptions()
	}
	{
		p.SetState(3240)
		p.Opttablespace()
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IOptnologContext is an interface to support dynamic dispatch.
type IOptnologContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	UNLOGGED() antlr.TerminalNode

	// IsOptnologContext differentiates from other interfaces.
	IsOptnologContext()
}

type OptnologContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyOptnologContext() *OptnologContext {
	var p = new(OptnologContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_optnolog
	return p
}

func InitEmptyOptnologContext(p *OptnologContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_optnolog
}

func (*OptnologContext) IsOptnologContext() {}

func NewOptnologContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *OptnologContext {
	var p = new(OptnologContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_optnolog

	return p
}

func (s *OptnologContext) GetParser() antlr.Parser { return s.parser }

func (s *OptnologContext) UNLOGGED() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserUNLOGGED, 0)
}

func (s *OptnologContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *OptnologContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *OptnologContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterOptnolog(s)
	}
}

func (s *OptnologContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitOptnolog(s)
	}
}

func (s *OptnologContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitOptnolog(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Optnolog() (localctx IOptnologContext) {
	localctx = NewOptnologContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 274, PostgreSQLParserRULE_optnolog)
	p.SetState(3244)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetTokenStream().LA(1) {
	case PostgreSQLParserUNLOGGED:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(3242)
			p.Match(PostgreSQLParserUNLOGGED)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case PostgreSQLParserMATERIALIZED:
		p.EnterOuterAlt(localctx, 2)

	default:
		p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IRefreshmatviewstmtContext is an interface to support dynamic dispatch.
type IRefreshmatviewstmtContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	REFRESH() antlr.TerminalNode
	MATERIALIZED() antlr.TerminalNode
	VIEW() antlr.TerminalNode
	Opt_concurrently() IOpt_concurrentlyContext
	Qualified_name() IQualified_nameContext
	Opt_with_data() IOpt_with_dataContext

	// IsRefreshmatviewstmtContext differentiates from other interfaces.
	IsRefreshmatviewstmtContext()
}

type RefreshmatviewstmtContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyRefreshmatviewstmtContext() *RefreshmatviewstmtContext {
	var p = new(RefreshmatviewstmtContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_refreshmatviewstmt
	return p
}

func InitEmptyRefreshmatviewstmtContext(p *RefreshmatviewstmtContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_refreshmatviewstmt
}

func (*RefreshmatviewstmtContext) IsRefreshmatviewstmtContext() {}

func NewRefreshmatviewstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *RefreshmatviewstmtContext {
	var p = new(RefreshmatviewstmtContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_refreshmatviewstmt

	return p
}

func (s *RefreshmatviewstmtContext) GetParser() antlr.Parser { return s.parser }

func (s *RefreshmatviewstmtContext) REFRESH() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserREFRESH, 0)
}

func (s *RefreshmatviewstmtContext) MATERIALIZED() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserMATERIALIZED, 0)
}

func (s *RefreshmatviewstmtContext) VIEW() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserVIEW, 0)
}

func (s *RefreshmatviewstmtContext) Opt_concurrently() IOpt_concurrentlyContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOpt_concurrentlyContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOpt_concurrentlyContext)
}

func (s *RefreshmatviewstmtContext) Qualified_name() IQualified_nameContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IQualified_nameContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IQualified_nameContext)
}

func (s *RefreshmatviewstmtContext) Opt_with_data() IOpt_with_dataContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOpt_with_dataContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOpt_with_dataContext)
}

func (s *RefreshmatviewstmtContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *RefreshmatviewstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *RefreshmatviewstmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterRefreshmatviewstmt(s)
	}
}

func (s *RefreshmatviewstmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitRefreshmatviewstmt(s)
	}
}

func (s *RefreshmatviewstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitRefreshmatviewstmt(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Refreshmatviewstmt() (localctx IRefreshmatviewstmtContext) {
	localctx = NewRefreshmatviewstmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 276, PostgreSQLParserRULE_refreshmatviewstmt)
	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(3246)
		p.Match(PostgreSQLParserREFRESH)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(3247)
		p.Match(PostgreSQLParserMATERIALIZED)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(3248)
		p.Match(PostgreSQLParserVIEW)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(3249)
		p.Opt_concurrently()
	}
	{
		p.SetState(3250)
		p.Qualified_name()
	}
	{
		p.SetState(3251)
		p.Opt_with_data()
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// ICreateseqstmtContext is an interface to support dynamic dispatch.
type ICreateseqstmtContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	CREATE() antlr.TerminalNode
	Opttemp() IOpttempContext
	SEQUENCE() antlr.TerminalNode
	Qualified_name() IQualified_nameContext
	Optseqoptlist() IOptseqoptlistContext
	IF_P() antlr.TerminalNode
	NOT() antlr.TerminalNode
	EXISTS() antlr.TerminalNode

	// IsCreateseqstmtContext differentiates from other interfaces.
	IsCreateseqstmtContext()
}

type CreateseqstmtContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyCreateseqstmtContext() *CreateseqstmtContext {
	var p = new(CreateseqstmtContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_createseqstmt
	return p
}

func InitEmptyCreateseqstmtContext(p *CreateseqstmtContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_createseqstmt
}

func (*CreateseqstmtContext) IsCreateseqstmtContext() {}

func NewCreateseqstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CreateseqstmtContext {
	var p = new(CreateseqstmtContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_createseqstmt

	return p
}

func (s *CreateseqstmtContext) GetParser() antlr.Parser { return s.parser }

func (s *CreateseqstmtContext) CREATE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCREATE, 0)
}

func (s *CreateseqstmtContext) Opttemp() IOpttempContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOpttempContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOpttempContext)
}

func (s *CreateseqstmtContext) SEQUENCE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserSEQUENCE, 0)
}

func (s *CreateseqstmtContext) Qualified_name() IQualified_nameContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IQualified_nameContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IQualified_nameContext)
}

func (s *CreateseqstmtContext) Optseqoptlist() IOptseqoptlistContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOptseqoptlistContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOptseqoptlistContext)
}

func (s *CreateseqstmtContext) IF_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserIF_P, 0)
}

func (s *CreateseqstmtContext) NOT() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserNOT, 0)
}

func (s *CreateseqstmtContext) EXISTS() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserEXISTS, 0)
}

func (s *CreateseqstmtContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *CreateseqstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *CreateseqstmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterCreateseqstmt(s)
	}
}

func (s *CreateseqstmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitCreateseqstmt(s)
	}
}

func (s *CreateseqstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitCreateseqstmt(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Createseqstmt() (localctx ICreateseqstmtContext) {
	localctx = NewCreateseqstmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 278, PostgreSQLParserRULE_createseqstmt)
	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(3253)
		p.Match(PostgreSQLParserCREATE)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(3254)
		p.Opttemp()
	}
	{
		p.SetState(3255)
		p.Match(PostgreSQLParserSEQUENCE)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	p.SetState(3259)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 129, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(3256)
			p.Match(PostgreSQLParserIF_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(3257)
			p.Match(PostgreSQLParserNOT)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(3258)
			p.Match(PostgreSQLParserEXISTS)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	} else if p.HasError() { // JIM
		goto errorExit
	}
	{
		p.SetState(3261)
		p.Qualified_name()
	}
	{
		p.SetState(3262)
		p.Optseqoptlist()
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IAlterseqstmtContext is an interface to support dynamic dispatch.
type IAlterseqstmtContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	ALTER() antlr.TerminalNode
	SEQUENCE() antlr.TerminalNode
	Qualified_name() IQualified_nameContext
	Seqoptlist() ISeqoptlistContext
	IF_P() antlr.TerminalNode
	EXISTS() antlr.TerminalNode

	// IsAlterseqstmtContext differentiates from other interfaces.
	IsAlterseqstmtContext()
}

type AlterseqstmtContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyAlterseqstmtContext() *AlterseqstmtContext {
	var p = new(AlterseqstmtContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_alterseqstmt
	return p
}

func InitEmptyAlterseqstmtContext(p *AlterseqstmtContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_alterseqstmt
}

func (*AlterseqstmtContext) IsAlterseqstmtContext() {}

func NewAlterseqstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AlterseqstmtContext {
	var p = new(AlterseqstmtContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_alterseqstmt

	return p
}

func (s *AlterseqstmtContext) GetParser() antlr.Parser { return s.parser }

func (s *AlterseqstmtContext) ALTER() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserALTER, 0)
}

func (s *AlterseqstmtContext) SEQUENCE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserSEQUENCE, 0)
}

func (s *AlterseqstmtContext) Qualified_name() IQualified_nameContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IQualified_nameContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IQualified_nameContext)
}

func (s *AlterseqstmtContext) Seqoptlist() ISeqoptlistContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ISeqoptlistContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ISeqoptlistContext)
}

func (s *AlterseqstmtContext) IF_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserIF_P, 0)
}

func (s *AlterseqstmtContext) EXISTS() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserEXISTS, 0)
}

func (s *AlterseqstmtContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *AlterseqstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *AlterseqstmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterAlterseqstmt(s)
	}
}

func (s *AlterseqstmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitAlterseqstmt(s)
	}
}

func (s *AlterseqstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitAlterseqstmt(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Alterseqstmt() (localctx IAlterseqstmtContext) {
	localctx = NewAlterseqstmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 280, PostgreSQLParserRULE_alterseqstmt)
	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(3264)
		p.Match(PostgreSQLParserALTER)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(3265)
		p.Match(PostgreSQLParserSEQUENCE)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	p.SetState(3268)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 130, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(3266)
			p.Match(PostgreSQLParserIF_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(3267)
			p.Match(PostgreSQLParserEXISTS)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	} else if p.HasError() { // JIM
		goto errorExit
	}
	{
		p.SetState(3270)
		p.Qualified_name()
	}
	{
		p.SetState(3271)
		p.Seqoptlist()
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IOptseqoptlistContext is an interface to support dynamic dispatch.
type IOptseqoptlistContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Seqoptlist() ISeqoptlistContext

	// IsOptseqoptlistContext differentiates from other interfaces.
	IsOptseqoptlistContext()
}

type OptseqoptlistContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyOptseqoptlistContext() *OptseqoptlistContext {
	var p = new(OptseqoptlistContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_optseqoptlist
	return p
}

func InitEmptyOptseqoptlistContext(p *OptseqoptlistContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_optseqoptlist
}

func (*OptseqoptlistContext) IsOptseqoptlistContext() {}

func NewOptseqoptlistContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *OptseqoptlistContext {
	var p = new(OptseqoptlistContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_optseqoptlist

	return p
}

func (s *OptseqoptlistContext) GetParser() antlr.Parser { return s.parser }

func (s *OptseqoptlistContext) Seqoptlist() ISeqoptlistContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ISeqoptlistContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ISeqoptlistContext)
}

func (s *OptseqoptlistContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *OptseqoptlistContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *OptseqoptlistContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterOptseqoptlist(s)
	}
}

func (s *OptseqoptlistContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitOptseqoptlist(s)
	}
}

func (s *OptseqoptlistContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitOptseqoptlist(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Optseqoptlist() (localctx IOptseqoptlistContext) {
	localctx = NewOptseqoptlistContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 282, PostgreSQLParserRULE_optseqoptlist)
	p.SetState(3275)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 131, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(3273)
			p.Seqoptlist()
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)

	case antlr.ATNInvalidAltNumber:
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IOptparenthesizedseqoptlistContext is an interface to support dynamic dispatch.
type IOptparenthesizedseqoptlistContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	OPEN_PAREN() antlr.TerminalNode
	Seqoptlist() ISeqoptlistContext
	CLOSE_PAREN() antlr.TerminalNode

	// IsOptparenthesizedseqoptlistContext differentiates from other interfaces.
	IsOptparenthesizedseqoptlistContext()
}

type OptparenthesizedseqoptlistContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyOptparenthesizedseqoptlistContext() *OptparenthesizedseqoptlistContext {
	var p = new(OptparenthesizedseqoptlistContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_optparenthesizedseqoptlist
	return p
}

func InitEmptyOptparenthesizedseqoptlistContext(p *OptparenthesizedseqoptlistContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_optparenthesizedseqoptlist
}

func (*OptparenthesizedseqoptlistContext) IsOptparenthesizedseqoptlistContext() {}

func NewOptparenthesizedseqoptlistContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *OptparenthesizedseqoptlistContext {
	var p = new(OptparenthesizedseqoptlistContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_optparenthesizedseqoptlist

	return p
}

func (s *OptparenthesizedseqoptlistContext) GetParser() antlr.Parser { return s.parser }

func (s *OptparenthesizedseqoptlistContext) OPEN_PAREN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserOPEN_PAREN, 0)
}

func (s *OptparenthesizedseqoptlistContext) Seqoptlist() ISeqoptlistContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ISeqoptlistContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ISeqoptlistContext)
}

func (s *OptparenthesizedseqoptlistContext) CLOSE_PAREN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCLOSE_PAREN, 0)
}

func (s *OptparenthesizedseqoptlistContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *OptparenthesizedseqoptlistContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *OptparenthesizedseqoptlistContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterOptparenthesizedseqoptlist(s)
	}
}

func (s *OptparenthesizedseqoptlistContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitOptparenthesizedseqoptlist(s)
	}
}

func (s *OptparenthesizedseqoptlistContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitOptparenthesizedseqoptlist(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Optparenthesizedseqoptlist() (localctx IOptparenthesizedseqoptlistContext) {
	localctx = NewOptparenthesizedseqoptlistContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 284, PostgreSQLParserRULE_optparenthesizedseqoptlist)
	p.SetState(3282)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 132, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(3277)
			p.Match(PostgreSQLParserOPEN_PAREN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(3278)
			p.Seqoptlist()
		}
		{
			p.SetState(3279)
			p.Match(PostgreSQLParserCLOSE_PAREN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)

	case antlr.ATNInvalidAltNumber:
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// ISeqoptlistContext is an interface to support dynamic dispatch.
type ISeqoptlistContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	AllSeqoptelem() []ISeqoptelemContext
	Seqoptelem(i int) ISeqoptelemContext

	// IsSeqoptlistContext differentiates from other interfaces.
	IsSeqoptlistContext()
}

type SeqoptlistContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptySeqoptlistContext() *SeqoptlistContext {
	var p = new(SeqoptlistContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_seqoptlist
	return p
}

func InitEmptySeqoptlistContext(p *SeqoptlistContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_seqoptlist
}

func (*SeqoptlistContext) IsSeqoptlistContext() {}

func NewSeqoptlistContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SeqoptlistContext {
	var p = new(SeqoptlistContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_seqoptlist

	return p
}

func (s *SeqoptlistContext) GetParser() antlr.Parser { return s.parser }

func (s *SeqoptlistContext) AllSeqoptelem() []ISeqoptelemContext {
	children := s.GetChildren()
	len := 0
	for _, ctx := range children {
		if _, ok := ctx.(ISeqoptelemContext); ok {
			len++
		}
	}

	tst := make([]ISeqoptelemContext, len)
	i := 0
	for _, ctx := range children {
		if t, ok := ctx.(ISeqoptelemContext); ok {
			tst[i] = t.(ISeqoptelemContext)
			i++
		}
	}

	return tst
}

func (s *SeqoptlistContext) Seqoptelem(i int) ISeqoptelemContext {
	var t antlr.RuleContext
	j := 0
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ISeqoptelemContext); ok {
			if j == i {
				t = ctx.(antlr.RuleContext)
				break
			}
			j++
		}
	}

	if t == nil {
		return nil
	}

	return t.(ISeqoptelemContext)
}

func (s *SeqoptlistContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *SeqoptlistContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *SeqoptlistContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterSeqoptlist(s)
	}
}

func (s *SeqoptlistContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitSeqoptlist(s)
	}
}

func (s *SeqoptlistContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitSeqoptlist(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Seqoptlist() (localctx ISeqoptlistContext) {
	localctx = NewSeqoptlistContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 286, PostgreSQLParserRULE_seqoptlist)
	var _alt int

	p.EnterOuterAlt(localctx, 1)
	p.SetState(3285)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}
	_alt = 1
	for ok := true; ok; ok = _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
		switch _alt {
		case 1:
			{
				p.SetState(3284)
				p.Seqoptelem()
			}

		default:
			p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
			goto errorExit
		}

		p.SetState(3287)
		p.GetErrorHandler().Sync(p)
		_alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 133, p.GetParserRuleContext())
		if p.HasError() {
			goto errorExit
		}
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// ISeqoptelemContext is an interface to support dynamic dispatch.
type ISeqoptelemContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	AS() antlr.TerminalNode
	Simpletypename() ISimpletypenameContext
	CACHE() antlr.TerminalNode
	Numericonly() INumericonlyContext
	CYCLE() antlr.TerminalNode
	INCREMENT() antlr.TerminalNode
	Opt_by() IOpt_byContext
	MAXVALUE() antlr.TerminalNode
	MINVALUE() antlr.TerminalNode
	NO() antlr.TerminalNode
	OWNED() antlr.TerminalNode
	BY() antlr.TerminalNode
	Any_name() IAny_nameContext
	SEQUENCE() antlr.TerminalNode
	NAME_P() antlr.TerminalNode
	START() antlr.TerminalNode
	Opt_with() IOpt_withContext
	RESTART() antlr.TerminalNode

	// IsSeqoptelemContext differentiates from other interfaces.
	IsSeqoptelemContext()
}

type SeqoptelemContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptySeqoptelemContext() *SeqoptelemContext {
	var p = new(SeqoptelemContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_seqoptelem
	return p
}

func InitEmptySeqoptelemContext(p *SeqoptelemContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_seqoptelem
}

func (*SeqoptelemContext) IsSeqoptelemContext() {}

func NewSeqoptelemContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SeqoptelemContext {
	var p = new(SeqoptelemContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_seqoptelem

	return p
}

func (s *SeqoptelemContext) GetParser() antlr.Parser { return s.parser }

func (s *SeqoptelemContext) AS() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserAS, 0)
}

func (s *SeqoptelemContext) Simpletypename() ISimpletypenameContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ISimpletypenameContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ISimpletypenameContext)
}

func (s *SeqoptelemContext) CACHE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCACHE, 0)
}

func (s *SeqoptelemContext) Numericonly() INumericonlyContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(INumericonlyContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(INumericonlyContext)
}

func (s *SeqoptelemContext) CYCLE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCYCLE, 0)
}

func (s *SeqoptelemContext) INCREMENT() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserINCREMENT, 0)
}

func (s *SeqoptelemContext) Opt_by() IOpt_byContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOpt_byContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOpt_byContext)
}

func (s *SeqoptelemContext) MAXVALUE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserMAXVALUE, 0)
}

func (s *SeqoptelemContext) MINVALUE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserMINVALUE, 0)
}

func (s *SeqoptelemContext) NO() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserNO, 0)
}

func (s *SeqoptelemContext) OWNED() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserOWNED, 0)
}

func (s *SeqoptelemContext) BY() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserBY, 0)
}

func (s *SeqoptelemContext) Any_name() IAny_nameContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IAny_nameContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IAny_nameContext)
}

func (s *SeqoptelemContext) SEQUENCE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserSEQUENCE, 0)
}

func (s *SeqoptelemContext) NAME_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserNAME_P, 0)
}

func (s *SeqoptelemContext) START() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserSTART, 0)
}

func (s *SeqoptelemContext) Opt_with() IOpt_withContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOpt_withContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOpt_withContext)
}

func (s *SeqoptelemContext) RESTART() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserRESTART, 0)
}

func (s *SeqoptelemContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *SeqoptelemContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *SeqoptelemContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterSeqoptelem(s)
	}
}

func (s *SeqoptelemContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitSeqoptelem(s)
	}
}

func (s *SeqoptelemContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitSeqoptelem(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Seqoptelem() (localctx ISeqoptelemContext) {
	localctx = NewSeqoptelemContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 288, PostgreSQLParserRULE_seqoptelem)
	var _la int

	p.SetState(3319)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetTokenStream().LA(1) {
	case PostgreSQLParserAS:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(3289)
			p.Match(PostgreSQLParserAS)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(3290)
			p.Simpletypename()
		}

	case PostgreSQLParserCACHE:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(3291)
			p.Match(PostgreSQLParserCACHE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(3292)
			p.Numericonly()
		}

	case PostgreSQLParserCYCLE:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(3293)
			p.Match(PostgreSQLParserCYCLE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case PostgreSQLParserINCREMENT:
		p.EnterOuterAlt(localctx, 4)
		{
			p.SetState(3294)
			p.Match(PostgreSQLParserINCREMENT)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(3295)
			p.Opt_by()
		}
		{
			p.SetState(3296)
			p.Numericonly()
		}

	case PostgreSQLParserMAXVALUE:
		p.EnterOuterAlt(localctx, 5)
		{
			p.SetState(3298)
			p.Match(PostgreSQLParserMAXVALUE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(3299)
			p.Numericonly()
		}

	case PostgreSQLParserMINVALUE:
		p.EnterOuterAlt(localctx, 6)
		{
			p.SetState(3300)
			p.Match(PostgreSQLParserMINVALUE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(3301)
			p.Numericonly()
		}

	case PostgreSQLParserNO:
		p.EnterOuterAlt(localctx, 7)
		{
			p.SetState(3302)
			p.Match(PostgreSQLParserNO)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(3303)
			_la = p.GetTokenStream().LA(1)

			if !(_la == PostgreSQLParserCYCLE || _la == PostgreSQLParserMAXVALUE || _la == PostgreSQLParserMINVALUE) {
				p.GetErrorHandler().RecoverInline(p)
			} else {
				p.GetErrorHandler().ReportMatch(p)
				p.Consume()
			}
		}

	case PostgreSQLParserOWNED:
		p.EnterOuterAlt(localctx, 8)
		{
			p.SetState(3304)
			p.Match(PostgreSQLParserOWNED)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(3305)
			p.Match(PostgreSQLParserBY)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(3306)
			p.Any_name()
		}

	case PostgreSQLParserSEQUENCE:
		p.EnterOuterAlt(localctx, 9)
		{
			p.SetState(3307)
			p.Match(PostgreSQLParserSEQUENCE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(3308)
			p.Match(PostgreSQLParserNAME_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(3309)
			p.Any_name()
		}

	case PostgreSQLParserSTART:
		p.EnterOuterAlt(localctx, 10)
		{
			p.SetState(3310)
			p.Match(PostgreSQLParserSTART)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(3311)
			p.Opt_with()
		}
		{
			p.SetState(3312)
			p.Numericonly()
		}

	case PostgreSQLParserRESTART:
		p.EnterOuterAlt(localctx, 11)
		{
			p.SetState(3314)
			p.Match(PostgreSQLParserRESTART)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(3315)
			p.Opt_with()
		}
		p.SetState(3317)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}
		_la = p.GetTokenStream().LA(1)

		if _la == PostgreSQLParserPLUS || _la == PostgreSQLParserMINUS || _la == PostgreSQLParserIntegral || _la == PostgreSQLParserNumeric {
			{
				p.SetState(3316)
				p.Numericonly()
			}

		}

	default:
		p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IOpt_byContext is an interface to support dynamic dispatch.
type IOpt_byContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	BY() antlr.TerminalNode

	// IsOpt_byContext differentiates from other interfaces.
	IsOpt_byContext()
}

type Opt_byContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyOpt_byContext() *Opt_byContext {
	var p = new(Opt_byContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opt_by
	return p
}

func InitEmptyOpt_byContext(p *Opt_byContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opt_by
}

func (*Opt_byContext) IsOpt_byContext() {}

func NewOpt_byContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_byContext {
	var p = new(Opt_byContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_opt_by

	return p
}

func (s *Opt_byContext) GetParser() antlr.Parser { return s.parser }

func (s *Opt_byContext) BY() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserBY, 0)
}

func (s *Opt_byContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Opt_byContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Opt_byContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterOpt_by(s)
	}
}

func (s *Opt_byContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitOpt_by(s)
	}
}

func (s *Opt_byContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitOpt_by(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Opt_by() (localctx IOpt_byContext) {
	localctx = NewOpt_byContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 290, PostgreSQLParserRULE_opt_by)
	p.SetState(3323)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetTokenStream().LA(1) {
	case PostgreSQLParserBY:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(3321)
			p.Match(PostgreSQLParserBY)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case PostgreSQLParserPLUS, PostgreSQLParserMINUS, PostgreSQLParserIntegral, PostgreSQLParserNumeric:
		p.EnterOuterAlt(localctx, 2)

	default:
		p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// INumericonlyContext is an interface to support dynamic dispatch.
type INumericonlyContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Fconst() IFconstContext
	PLUS() antlr.TerminalNode
	MINUS() antlr.TerminalNode
	Signediconst() ISignediconstContext

	// IsNumericonlyContext differentiates from other interfaces.
	IsNumericonlyContext()
}

type NumericonlyContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyNumericonlyContext() *NumericonlyContext {
	var p = new(NumericonlyContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_numericonly
	return p
}

func InitEmptyNumericonlyContext(p *NumericonlyContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_numericonly
}

func (*NumericonlyContext) IsNumericonlyContext() {}

func NewNumericonlyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *NumericonlyContext {
	var p = new(NumericonlyContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_numericonly

	return p
}

func (s *NumericonlyContext) GetParser() antlr.Parser { return s.parser }

func (s *NumericonlyContext) Fconst() IFconstContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IFconstContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IFconstContext)
}

func (s *NumericonlyContext) PLUS() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserPLUS, 0)
}

func (s *NumericonlyContext) MINUS() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserMINUS, 0)
}

func (s *NumericonlyContext) Signediconst() ISignediconstContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ISignediconstContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ISignediconstContext)
}

func (s *NumericonlyContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *NumericonlyContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *NumericonlyContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterNumericonly(s)
	}
}

func (s *NumericonlyContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitNumericonly(s)
	}
}

func (s *NumericonlyContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitNumericonly(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Numericonly() (localctx INumericonlyContext) {
	localctx = NewNumericonlyContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 292, PostgreSQLParserRULE_numericonly)
	p.SetState(3331)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 137, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(3325)
			p.Fconst()
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(3326)
			p.Match(PostgreSQLParserPLUS)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(3327)
			p.Fconst()
		}

	case 3:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(3328)
			p.Match(PostgreSQLParserMINUS)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(3329)
			p.Fconst()
		}

	case 4:
		p.EnterOuterAlt(localctx, 4)
		{
			p.SetState(3330)
			p.Signediconst()
		}

	case antlr.ATNInvalidAltNumber:
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// INumericonly_listContext is an interface to support dynamic dispatch.
type INumericonly_listContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	AllNumericonly() []INumericonlyContext
	Numericonly(i int) INumericonlyContext
	AllCOMMA() []antlr.TerminalNode
	COMMA(i int) antlr.TerminalNode

	// IsNumericonly_listContext differentiates from other interfaces.
	IsNumericonly_listContext()
}

type Numericonly_listContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyNumericonly_listContext() *Numericonly_listContext {
	var p = new(Numericonly_listContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_numericonly_list
	return p
}

func InitEmptyNumericonly_listContext(p *Numericonly_listContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_numericonly_list
}

func (*Numericonly_listContext) IsNumericonly_listContext() {}

func NewNumericonly_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Numericonly_listContext {
	var p = new(Numericonly_listContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_numericonly_list

	return p
}

func (s *Numericonly_listContext) GetParser() antlr.Parser { return s.parser }

func (s *Numericonly_listContext) AllNumericonly() []INumericonlyContext {
	children := s.GetChildren()
	len := 0
	for _, ctx := range children {
		if _, ok := ctx.(INumericonlyContext); ok {
			len++
		}
	}

	tst := make([]INumericonlyContext, len)
	i := 0
	for _, ctx := range children {
		if t, ok := ctx.(INumericonlyContext); ok {
			tst[i] = t.(INumericonlyContext)
			i++
		}
	}

	return tst
}

func (s *Numericonly_listContext) Numericonly(i int) INumericonlyContext {
	var t antlr.RuleContext
	j := 0
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(INumericonlyContext); ok {
			if j == i {
				t = ctx.(antlr.RuleContext)
				break
			}
			j++
		}
	}

	if t == nil {
		return nil
	}

	return t.(INumericonlyContext)
}

func (s *Numericonly_listContext) AllCOMMA() []antlr.TerminalNode {
	return s.GetTokens(PostgreSQLParserCOMMA)
}

func (s *Numericonly_listContext) COMMA(i int) antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCOMMA, i)
}

func (s *Numericonly_listContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Numericonly_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Numericonly_listContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterNumericonly_list(s)
	}
}

func (s *Numericonly_listContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitNumericonly_list(s)
	}
}

func (s *Numericonly_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitNumericonly_list(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Numericonly_list() (localctx INumericonly_listContext) {
	localctx = NewNumericonly_listContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 294, PostgreSQLParserRULE_numericonly_list)
	var _la int

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(3333)
		p.Numericonly()
	}
	p.SetState(3338)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}
	_la = p.GetTokenStream().LA(1)

	for _la == PostgreSQLParserCOMMA {
		{
			p.SetState(3334)
			p.Match(PostgreSQLParserCOMMA)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(3335)
			p.Numericonly()
		}

		p.SetState(3340)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}
		_la = p.GetTokenStream().LA(1)
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// ICreateplangstmtContext is an interface to support dynamic dispatch.
type ICreateplangstmtContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	CREATE() antlr.TerminalNode
	Opt_or_replace() IOpt_or_replaceContext
	Opt_trusted() IOpt_trustedContext
	Opt_procedural() IOpt_proceduralContext
	LANGUAGE() antlr.TerminalNode
	Name() INameContext
	HANDLER() antlr.TerminalNode
	Handler_name() IHandler_nameContext
	Opt_inline_handler() IOpt_inline_handlerContext
	Opt_validator() IOpt_validatorContext

	// IsCreateplangstmtContext differentiates from other interfaces.
	IsCreateplangstmtContext()
}

type CreateplangstmtContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyCreateplangstmtContext() *CreateplangstmtContext {
	var p = new(CreateplangstmtContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_createplangstmt
	return p
}

func InitEmptyCreateplangstmtContext(p *CreateplangstmtContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_createplangstmt
}

func (*CreateplangstmtContext) IsCreateplangstmtContext() {}

func NewCreateplangstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CreateplangstmtContext {
	var p = new(CreateplangstmtContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_createplangstmt

	return p
}

func (s *CreateplangstmtContext) GetParser() antlr.Parser { return s.parser }

func (s *CreateplangstmtContext) CREATE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCREATE, 0)
}

func (s *CreateplangstmtContext) Opt_or_replace() IOpt_or_replaceContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOpt_or_replaceContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOpt_or_replaceContext)
}

func (s *CreateplangstmtContext) Opt_trusted() IOpt_trustedContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOpt_trustedContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOpt_trustedContext)
}

func (s *CreateplangstmtContext) Opt_procedural() IOpt_proceduralContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOpt_proceduralContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOpt_proceduralContext)
}

func (s *CreateplangstmtContext) LANGUAGE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserLANGUAGE, 0)
}

func (s *CreateplangstmtContext) Name() INameContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(INameContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(INameContext)
}

func (s *CreateplangstmtContext) HANDLER() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserHANDLER, 0)
}

func (s *CreateplangstmtContext) Handler_name() IHandler_nameContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IHandler_nameContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IHandler_nameContext)
}

func (s *CreateplangstmtContext) Opt_inline_handler() IOpt_inline_handlerContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOpt_inline_handlerContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOpt_inline_handlerContext)
}

func (s *CreateplangstmtContext) Opt_validator() IOpt_validatorContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOpt_validatorContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOpt_validatorContext)
}

func (s *CreateplangstmtContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *CreateplangstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *CreateplangstmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterCreateplangstmt(s)
	}
}

func (s *CreateplangstmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitCreateplangstmt(s)
	}
}

func (s *CreateplangstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitCreateplangstmt(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Createplangstmt() (localctx ICreateplangstmtContext) {
	localctx = NewCreateplangstmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 296, PostgreSQLParserRULE_createplangstmt)
	var _la int

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(3341)
		p.Match(PostgreSQLParserCREATE)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(3342)
		p.Opt_or_replace()
	}
	{
		p.SetState(3343)
		p.Opt_trusted()
	}
	{
		p.SetState(3344)
		p.Opt_procedural()
	}
	{
		p.SetState(3345)
		p.Match(PostgreSQLParserLANGUAGE)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(3346)
		p.Name()
	}
	p.SetState(3352)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}
	_la = p.GetTokenStream().LA(1)

	if _la == PostgreSQLParserHANDLER {
		{
			p.SetState(3347)
			p.Match(PostgreSQLParserHANDLER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(3348)
			p.Handler_name()
		}
		{
			p.SetState(3349)
			p.Opt_inline_handler()
		}
		{
			p.SetState(3350)
			p.Opt_validator()
		}

	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IOpt_trustedContext is an interface to support dynamic dispatch.
type IOpt_trustedContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	TRUSTED() antlr.TerminalNode

	// IsOpt_trustedContext differentiates from other interfaces.
	IsOpt_trustedContext()
}

type Opt_trustedContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyOpt_trustedContext() *Opt_trustedContext {
	var p = new(Opt_trustedContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opt_trusted
	return p
}

func InitEmptyOpt_trustedContext(p *Opt_trustedContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opt_trusted
}

func (*Opt_trustedContext) IsOpt_trustedContext() {}

func NewOpt_trustedContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_trustedContext {
	var p = new(Opt_trustedContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_opt_trusted

	return p
}

func (s *Opt_trustedContext) GetParser() antlr.Parser { return s.parser }

func (s *Opt_trustedContext) TRUSTED() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserTRUSTED, 0)
}

func (s *Opt_trustedContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Opt_trustedContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Opt_trustedContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterOpt_trusted(s)
	}
}

func (s *Opt_trustedContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitOpt_trusted(s)
	}
}

func (s *Opt_trustedContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitOpt_trusted(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Opt_trusted() (localctx IOpt_trustedContext) {
	localctx = NewOpt_trustedContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 298, PostgreSQLParserRULE_opt_trusted)
	p.SetState(3356)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetTokenStream().LA(1) {
	case PostgreSQLParserTRUSTED:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(3354)
			p.Match(PostgreSQLParserTRUSTED)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case PostgreSQLParserLANGUAGE, PostgreSQLParserPROCEDURAL:
		p.EnterOuterAlt(localctx, 2)

	default:
		p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IHandler_nameContext is an interface to support dynamic dispatch.
type IHandler_nameContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Name() INameContext
	Attrs() IAttrsContext

	// IsHandler_nameContext differentiates from other interfaces.
	IsHandler_nameContext()
}

type Handler_nameContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyHandler_nameContext() *Handler_nameContext {
	var p = new(Handler_nameContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_handler_name
	return p
}

func InitEmptyHandler_nameContext(p *Handler_nameContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_handler_name
}

func (*Handler_nameContext) IsHandler_nameContext() {}

func NewHandler_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Handler_nameContext {
	var p = new(Handler_nameContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_handler_name

	return p
}

func (s *Handler_nameContext) GetParser() antlr.Parser { return s.parser }

func (s *Handler_nameContext) Name() INameContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(INameContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(INameContext)
}

func (s *Handler_nameContext) Attrs() IAttrsContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IAttrsContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IAttrsContext)
}

func (s *Handler_nameContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Handler_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Handler_nameContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterHandler_name(s)
	}
}

func (s *Handler_nameContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitHandler_name(s)
	}
}

func (s *Handler_nameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitHandler_name(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Handler_name() (localctx IHandler_nameContext) {
	localctx = NewHandler_nameContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 300, PostgreSQLParserRULE_handler_name)
	var _la int

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(3358)
		p.Name()
	}
	p.SetState(3360)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}
	_la = p.GetTokenStream().LA(1)

	if _la == PostgreSQLParserDOT {
		{
			p.SetState(3359)
			p.Attrs()
		}

	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IOpt_inline_handlerContext is an interface to support dynamic dispatch.
type IOpt_inline_handlerContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	INLINE_P() antlr.TerminalNode
	Handler_name() IHandler_nameContext

	// IsOpt_inline_handlerContext differentiates from other interfaces.
	IsOpt_inline_handlerContext()
}

type Opt_inline_handlerContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyOpt_inline_handlerContext() *Opt_inline_handlerContext {
	var p = new(Opt_inline_handlerContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opt_inline_handler
	return p
}

func InitEmptyOpt_inline_handlerContext(p *Opt_inline_handlerContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opt_inline_handler
}

func (*Opt_inline_handlerContext) IsOpt_inline_handlerContext() {}

func NewOpt_inline_handlerContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_inline_handlerContext {
	var p = new(Opt_inline_handlerContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_opt_inline_handler

	return p
}

func (s *Opt_inline_handlerContext) GetParser() antlr.Parser { return s.parser }

func (s *Opt_inline_handlerContext) INLINE_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserINLINE_P, 0)
}

func (s *Opt_inline_handlerContext) Handler_name() IHandler_nameContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IHandler_nameContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IHandler_nameContext)
}

func (s *Opt_inline_handlerContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Opt_inline_handlerContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Opt_inline_handlerContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterOpt_inline_handler(s)
	}
}

func (s *Opt_inline_handlerContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitOpt_inline_handler(s)
	}
}

func (s *Opt_inline_handlerContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitOpt_inline_handler(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Opt_inline_handler() (localctx IOpt_inline_handlerContext) {
	localctx = NewOpt_inline_handlerContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 302, PostgreSQLParserRULE_opt_inline_handler)
	p.SetState(3365)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetTokenStream().LA(1) {
	case PostgreSQLParserINLINE_P:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(3362)
			p.Match(PostgreSQLParserINLINE_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(3363)
			p.Handler_name()
		}

	case PostgreSQLParserEOF, PostgreSQLParserOPEN_PAREN, PostgreSQLParserSEMI, PostgreSQLParserANALYSE, PostgreSQLParserANALYZE, PostgreSQLParserCREATE, PostgreSQLParserDO, PostgreSQLParserFETCH, PostgreSQLParserGRANT, PostgreSQLParserINTO, PostgreSQLParserSELECT, PostgreSQLParserTABLE, PostgreSQLParserWITH, PostgreSQLParserABORT_P, PostgreSQLParserALTER, PostgreSQLParserBEGIN_P, PostgreSQLParserCHECKPOINT, PostgreSQLParserCLOSE, PostgreSQLParserCLUSTER, PostgreSQLParserCOMMENT, PostgreSQLParserCOMMIT, PostgreSQLParserCOPY, PostgreSQLParserDEALLOCATE, PostgreSQLParserDECLARE, PostgreSQLParserDELETE_P, PostgreSQLParserDISCARD, PostgreSQLParserDROP, PostgreSQLParserEXECUTE, PostgreSQLParserEXPLAIN, PostgreSQLParserINSERT, PostgreSQLParserLISTEN, PostgreSQLParserLOAD, PostgreSQLParserLOCK_P, PostgreSQLParserMERGE, PostgreSQLParserMOVE, PostgreSQLParserNO, PostgreSQLParserNOTIFY, PostgreSQLParserPREPARE, PostgreSQLParserREASSIGN, PostgreSQLParserREFRESH, PostgreSQLParserREINDEX, PostgreSQLParserRELEASE, PostgreSQLParserRESET, PostgreSQLParserREVOKE, PostgreSQLParserROLLBACK, PostgreSQLParserSAVEPOINT, PostgreSQLParserSECURITY, PostgreSQLParserSET, PostgreSQLParserSHOW, PostgreSQLParserSTART, PostgreSQLParserTRUNCATE, PostgreSQLParserUNLISTEN, PostgreSQLParserUPDATE, PostgreSQLParserVACUUM, PostgreSQLParserVALIDATOR, PostgreSQLParserVALUES, PostgreSQLParserCALL, PostgreSQLParserIMPORT_P, PostgreSQLParserEND_P, PostgreSQLParserMetaCommand:
		p.EnterOuterAlt(localctx, 2)

	default:
		p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IValidator_clauseContext is an interface to support dynamic dispatch.
type IValidator_clauseContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	VALIDATOR() antlr.TerminalNode
	Handler_name() IHandler_nameContext
	NO() antlr.TerminalNode

	// IsValidator_clauseContext differentiates from other interfaces.
	IsValidator_clauseContext()
}

type Validator_clauseContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyValidator_clauseContext() *Validator_clauseContext {
	var p = new(Validator_clauseContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_validator_clause
	return p
}

func InitEmptyValidator_clauseContext(p *Validator_clauseContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_validator_clause
}

func (*Validator_clauseContext) IsValidator_clauseContext() {}

func NewValidator_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Validator_clauseContext {
	var p = new(Validator_clauseContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_validator_clause

	return p
}

func (s *Validator_clauseContext) GetParser() antlr.Parser { return s.parser }

func (s *Validator_clauseContext) VALIDATOR() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserVALIDATOR, 0)
}

func (s *Validator_clauseContext) Handler_name() IHandler_nameContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IHandler_nameContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IHandler_nameContext)
}

func (s *Validator_clauseContext) NO() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserNO, 0)
}

func (s *Validator_clauseContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Validator_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Validator_clauseContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterValidator_clause(s)
	}
}

func (s *Validator_clauseContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitValidator_clause(s)
	}
}

func (s *Validator_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitValidator_clause(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Validator_clause() (localctx IValidator_clauseContext) {
	localctx = NewValidator_clauseContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 304, PostgreSQLParserRULE_validator_clause)
	p.SetState(3371)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetTokenStream().LA(1) {
	case PostgreSQLParserVALIDATOR:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(3367)
			p.Match(PostgreSQLParserVALIDATOR)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(3368)
			p.Handler_name()
		}

	case PostgreSQLParserNO:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(3369)
			p.Match(PostgreSQLParserNO)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(3370)
			p.Match(PostgreSQLParserVALIDATOR)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	default:
		p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IOpt_validatorContext is an interface to support dynamic dispatch.
type IOpt_validatorContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Validator_clause() IValidator_clauseContext

	// IsOpt_validatorContext differentiates from other interfaces.
	IsOpt_validatorContext()
}

type Opt_validatorContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyOpt_validatorContext() *Opt_validatorContext {
	var p = new(Opt_validatorContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opt_validator
	return p
}

func InitEmptyOpt_validatorContext(p *Opt_validatorContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opt_validator
}

func (*Opt_validatorContext) IsOpt_validatorContext() {}

func NewOpt_validatorContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_validatorContext {
	var p = new(Opt_validatorContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_opt_validator

	return p
}

func (s *Opt_validatorContext) GetParser() antlr.Parser { return s.parser }

func (s *Opt_validatorContext) Validator_clause() IValidator_clauseContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IValidator_clauseContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IValidator_clauseContext)
}

func (s *Opt_validatorContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Opt_validatorContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Opt_validatorContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterOpt_validator(s)
	}
}

func (s *Opt_validatorContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitOpt_validator(s)
	}
}

func (s *Opt_validatorContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitOpt_validator(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Opt_validator() (localctx IOpt_validatorContext) {
	localctx = NewOpt_validatorContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 306, PostgreSQLParserRULE_opt_validator)
	p.SetState(3375)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetTokenStream().LA(1) {
	case PostgreSQLParserNO, PostgreSQLParserVALIDATOR:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(3373)
			p.Validator_clause()
		}

	case PostgreSQLParserEOF, PostgreSQLParserOPEN_PAREN, PostgreSQLParserSEMI, PostgreSQLParserANALYSE, PostgreSQLParserANALYZE, PostgreSQLParserCREATE, PostgreSQLParserDO, PostgreSQLParserFETCH, PostgreSQLParserGRANT, PostgreSQLParserINTO, PostgreSQLParserSELECT, PostgreSQLParserTABLE, PostgreSQLParserWITH, PostgreSQLParserABORT_P, PostgreSQLParserALTER, PostgreSQLParserBEGIN_P, PostgreSQLParserCHECKPOINT, PostgreSQLParserCLOSE, PostgreSQLParserCLUSTER, PostgreSQLParserCOMMENT, PostgreSQLParserCOMMIT, PostgreSQLParserCOPY, PostgreSQLParserDEALLOCATE, PostgreSQLParserDECLARE, PostgreSQLParserDELETE_P, PostgreSQLParserDISCARD, PostgreSQLParserDROP, PostgreSQLParserEXECUTE, PostgreSQLParserEXPLAIN, PostgreSQLParserINSERT, PostgreSQLParserLISTEN, PostgreSQLParserLOAD, PostgreSQLParserLOCK_P, PostgreSQLParserMERGE, PostgreSQLParserMOVE, PostgreSQLParserNOTIFY, PostgreSQLParserPREPARE, PostgreSQLParserREASSIGN, PostgreSQLParserREFRESH, PostgreSQLParserREINDEX, PostgreSQLParserRELEASE, PostgreSQLParserRESET, PostgreSQLParserREVOKE, PostgreSQLParserROLLBACK, PostgreSQLParserSAVEPOINT, PostgreSQLParserSECURITY, PostgreSQLParserSET, PostgreSQLParserSHOW, PostgreSQLParserSTART, PostgreSQLParserTRUNCATE, PostgreSQLParserUNLISTEN, PostgreSQLParserUPDATE, PostgreSQLParserVACUUM, PostgreSQLParserVALUES, PostgreSQLParserCALL, PostgreSQLParserIMPORT_P, PostgreSQLParserEND_P, PostgreSQLParserMetaCommand:
		p.EnterOuterAlt(localctx, 2)

	default:
		p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IOpt_proceduralContext is an interface to support dynamic dispatch.
type IOpt_proceduralContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	PROCEDURAL() antlr.TerminalNode

	// IsOpt_proceduralContext differentiates from other interfaces.
	IsOpt_proceduralContext()
}

type Opt_proceduralContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyOpt_proceduralContext() *Opt_proceduralContext {
	var p = new(Opt_proceduralContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opt_procedural
	return p
}

func InitEmptyOpt_proceduralContext(p *Opt_proceduralContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opt_procedural
}

func (*Opt_proceduralContext) IsOpt_proceduralContext() {}

func NewOpt_proceduralContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_proceduralContext {
	var p = new(Opt_proceduralContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_opt_procedural

	return p
}

func (s *Opt_proceduralContext) GetParser() antlr.Parser { return s.parser }

func (s *Opt_proceduralContext) PROCEDURAL() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserPROCEDURAL, 0)
}

func (s *Opt_proceduralContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Opt_proceduralContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Opt_proceduralContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterOpt_procedural(s)
	}
}

func (s *Opt_proceduralContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitOpt_procedural(s)
	}
}

func (s *Opt_proceduralContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitOpt_procedural(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Opt_procedural() (localctx IOpt_proceduralContext) {
	localctx = NewOpt_proceduralContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 308, PostgreSQLParserRULE_opt_procedural)
	p.SetState(3379)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetTokenStream().LA(1) {
	case PostgreSQLParserPROCEDURAL:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(3377)
			p.Match(PostgreSQLParserPROCEDURAL)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case PostgreSQLParserLANGUAGE:
		p.EnterOuterAlt(localctx, 2)

	default:
		p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// ICreatetablespacestmtContext is an interface to support dynamic dispatch.
type ICreatetablespacestmtContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	CREATE() antlr.TerminalNode
	TABLESPACE() antlr.TerminalNode
	Name() INameContext
	Opttablespaceowner() IOpttablespaceownerContext
	LOCATION() antlr.TerminalNode
	Sconst() ISconstContext
	Opt_reloptions() IOpt_reloptionsContext

	// IsCreatetablespacestmtContext differentiates from other interfaces.
	IsCreatetablespacestmtContext()
}

type CreatetablespacestmtContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyCreatetablespacestmtContext() *CreatetablespacestmtContext {
	var p = new(CreatetablespacestmtContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_createtablespacestmt
	return p
}

func InitEmptyCreatetablespacestmtContext(p *CreatetablespacestmtContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_createtablespacestmt
}

func (*CreatetablespacestmtContext) IsCreatetablespacestmtContext() {}

func NewCreatetablespacestmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CreatetablespacestmtContext {
	var p = new(CreatetablespacestmtContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_createtablespacestmt

	return p
}

func (s *CreatetablespacestmtContext) GetParser() antlr.Parser { return s.parser }

func (s *CreatetablespacestmtContext) CREATE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCREATE, 0)
}

func (s *CreatetablespacestmtContext) TABLESPACE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserTABLESPACE, 0)
}

func (s *CreatetablespacestmtContext) Name() INameContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(INameContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(INameContext)
}

func (s *CreatetablespacestmtContext) Opttablespaceowner() IOpttablespaceownerContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOpttablespaceownerContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOpttablespaceownerContext)
}

func (s *CreatetablespacestmtContext) LOCATION() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserLOCATION, 0)
}

func (s *CreatetablespacestmtContext) Sconst() ISconstContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ISconstContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ISconstContext)
}

func (s *CreatetablespacestmtContext) Opt_reloptions() IOpt_reloptionsContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOpt_reloptionsContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOpt_reloptionsContext)
}

func (s *CreatetablespacestmtContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *CreatetablespacestmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *CreatetablespacestmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterCreatetablespacestmt(s)
	}
}

func (s *CreatetablespacestmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitCreatetablespacestmt(s)
	}
}

func (s *CreatetablespacestmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitCreatetablespacestmt(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Createtablespacestmt() (localctx ICreatetablespacestmtContext) {
	localctx = NewCreatetablespacestmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 310, PostgreSQLParserRULE_createtablespacestmt)
	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(3381)
		p.Match(PostgreSQLParserCREATE)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(3382)
		p.Match(PostgreSQLParserTABLESPACE)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(3383)
		p.Name()
	}
	{
		p.SetState(3384)
		p.Opttablespaceowner()
	}
	{
		p.SetState(3385)
		p.Match(PostgreSQLParserLOCATION)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(3386)
		p.Sconst()
	}
	{
		p.SetState(3387)
		p.Opt_reloptions()
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IOpttablespaceownerContext is an interface to support dynamic dispatch.
type IOpttablespaceownerContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	OWNER() antlr.TerminalNode
	Rolespec() IRolespecContext

	// IsOpttablespaceownerContext differentiates from other interfaces.
	IsOpttablespaceownerContext()
}

type OpttablespaceownerContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyOpttablespaceownerContext() *OpttablespaceownerContext {
	var p = new(OpttablespaceownerContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opttablespaceowner
	return p
}

func InitEmptyOpttablespaceownerContext(p *OpttablespaceownerContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opttablespaceowner
}

func (*OpttablespaceownerContext) IsOpttablespaceownerContext() {}

func NewOpttablespaceownerContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *OpttablespaceownerContext {
	var p = new(OpttablespaceownerContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_opttablespaceowner

	return p
}

func (s *OpttablespaceownerContext) GetParser() antlr.Parser { return s.parser }

func (s *OpttablespaceownerContext) OWNER() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserOWNER, 0)
}

func (s *OpttablespaceownerContext) Rolespec() IRolespecContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IRolespecContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IRolespecContext)
}

func (s *OpttablespaceownerContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *OpttablespaceownerContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *OpttablespaceownerContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterOpttablespaceowner(s)
	}
}

func (s *OpttablespaceownerContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitOpttablespaceowner(s)
	}
}

func (s *OpttablespaceownerContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitOpttablespaceowner(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Opttablespaceowner() (localctx IOpttablespaceownerContext) {
	localctx = NewOpttablespaceownerContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 312, PostgreSQLParserRULE_opttablespaceowner)
	p.SetState(3392)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetTokenStream().LA(1) {
	case PostgreSQLParserOWNER:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(3389)
			p.Match(PostgreSQLParserOWNER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(3390)
			p.Rolespec()
		}

	case PostgreSQLParserLOCATION:
		p.EnterOuterAlt(localctx, 2)

	default:
		p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IDroptablespacestmtContext is an interface to support dynamic dispatch.
type IDroptablespacestmtContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	DROP() antlr.TerminalNode
	TABLESPACE() antlr.TerminalNode
	Name() INameContext
	IF_P() antlr.TerminalNode
	EXISTS() antlr.TerminalNode

	// IsDroptablespacestmtContext differentiates from other interfaces.
	IsDroptablespacestmtContext()
}

type DroptablespacestmtContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyDroptablespacestmtContext() *DroptablespacestmtContext {
	var p = new(DroptablespacestmtContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_droptablespacestmt
	return p
}

func InitEmptyDroptablespacestmtContext(p *DroptablespacestmtContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_droptablespacestmt
}

func (*DroptablespacestmtContext) IsDroptablespacestmtContext() {}

func NewDroptablespacestmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DroptablespacestmtContext {
	var p = new(DroptablespacestmtContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_droptablespacestmt

	return p
}

func (s *DroptablespacestmtContext) GetParser() antlr.Parser { return s.parser }

func (s *DroptablespacestmtContext) DROP() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserDROP, 0)
}

func (s *DroptablespacestmtContext) TABLESPACE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserTABLESPACE, 0)
}

func (s *DroptablespacestmtContext) Name() INameContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(INameContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(INameContext)
}

func (s *DroptablespacestmtContext) IF_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserIF_P, 0)
}

func (s *DroptablespacestmtContext) EXISTS() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserEXISTS, 0)
}

func (s *DroptablespacestmtContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *DroptablespacestmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *DroptablespacestmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterDroptablespacestmt(s)
	}
}

func (s *DroptablespacestmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitDroptablespacestmt(s)
	}
}

func (s *DroptablespacestmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitDroptablespacestmt(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Droptablespacestmt() (localctx IDroptablespacestmtContext) {
	localctx = NewDroptablespacestmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 314, PostgreSQLParserRULE_droptablespacestmt)
	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(3394)
		p.Match(PostgreSQLParserDROP)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(3395)
		p.Match(PostgreSQLParserTABLESPACE)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	p.SetState(3398)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 147, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(3396)
			p.Match(PostgreSQLParserIF_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(3397)
			p.Match(PostgreSQLParserEXISTS)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	} else if p.HasError() { // JIM
		goto errorExit
	}
	{
		p.SetState(3400)
		p.Name()
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// ICreateextensionstmtContext is an interface to support dynamic dispatch.
type ICreateextensionstmtContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	CREATE() antlr.TerminalNode
	EXTENSION() antlr.TerminalNode
	Name() INameContext
	Opt_with() IOpt_withContext
	Create_extension_opt_list() ICreate_extension_opt_listContext
	IF_P() antlr.TerminalNode
	NOT() antlr.TerminalNode
	EXISTS() antlr.TerminalNode

	// IsCreateextensionstmtContext differentiates from other interfaces.
	IsCreateextensionstmtContext()
}

type CreateextensionstmtContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyCreateextensionstmtContext() *CreateextensionstmtContext {
	var p = new(CreateextensionstmtContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_createextensionstmt
	return p
}

func InitEmptyCreateextensionstmtContext(p *CreateextensionstmtContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_createextensionstmt
}

func (*CreateextensionstmtContext) IsCreateextensionstmtContext() {}

func NewCreateextensionstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CreateextensionstmtContext {
	var p = new(CreateextensionstmtContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_createextensionstmt

	return p
}

func (s *CreateextensionstmtContext) GetParser() antlr.Parser { return s.parser }

func (s *CreateextensionstmtContext) CREATE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCREATE, 0)
}

func (s *CreateextensionstmtContext) EXTENSION() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserEXTENSION, 0)
}

func (s *CreateextensionstmtContext) Name() INameContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(INameContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(INameContext)
}

func (s *CreateextensionstmtContext) Opt_with() IOpt_withContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOpt_withContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOpt_withContext)
}

func (s *CreateextensionstmtContext) Create_extension_opt_list() ICreate_extension_opt_listContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ICreate_extension_opt_listContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ICreate_extension_opt_listContext)
}

func (s *CreateextensionstmtContext) IF_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserIF_P, 0)
}

func (s *CreateextensionstmtContext) NOT() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserNOT, 0)
}

func (s *CreateextensionstmtContext) EXISTS() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserEXISTS, 0)
}

func (s *CreateextensionstmtContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *CreateextensionstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *CreateextensionstmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterCreateextensionstmt(s)
	}
}

func (s *CreateextensionstmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitCreateextensionstmt(s)
	}
}

func (s *CreateextensionstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitCreateextensionstmt(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Createextensionstmt() (localctx ICreateextensionstmtContext) {
	localctx = NewCreateextensionstmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 316, PostgreSQLParserRULE_createextensionstmt)
	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(3402)
		p.Match(PostgreSQLParserCREATE)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(3403)
		p.Match(PostgreSQLParserEXTENSION)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	p.SetState(3407)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 148, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(3404)
			p.Match(PostgreSQLParserIF_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(3405)
			p.Match(PostgreSQLParserNOT)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(3406)
			p.Match(PostgreSQLParserEXISTS)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	} else if p.HasError() { // JIM
		goto errorExit
	}
	{
		p.SetState(3409)
		p.Name()
	}
	{
		p.SetState(3410)
		p.Opt_with()
	}
	{
		p.SetState(3411)
		p.Create_extension_opt_list()
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// ICreate_extension_opt_listContext is an interface to support dynamic dispatch.
type ICreate_extension_opt_listContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	AllCreate_extension_opt_item() []ICreate_extension_opt_itemContext
	Create_extension_opt_item(i int) ICreate_extension_opt_itemContext

	// IsCreate_extension_opt_listContext differentiates from other interfaces.
	IsCreate_extension_opt_listContext()
}

type Create_extension_opt_listContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyCreate_extension_opt_listContext() *Create_extension_opt_listContext {
	var p = new(Create_extension_opt_listContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_create_extension_opt_list
	return p
}

func InitEmptyCreate_extension_opt_listContext(p *Create_extension_opt_listContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_create_extension_opt_list
}

func (*Create_extension_opt_listContext) IsCreate_extension_opt_listContext() {}

func NewCreate_extension_opt_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_extension_opt_listContext {
	var p = new(Create_extension_opt_listContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_create_extension_opt_list

	return p
}

func (s *Create_extension_opt_listContext) GetParser() antlr.Parser { return s.parser }

func (s *Create_extension_opt_listContext) AllCreate_extension_opt_item() []ICreate_extension_opt_itemContext {
	children := s.GetChildren()
	len := 0
	for _, ctx := range children {
		if _, ok := ctx.(ICreate_extension_opt_itemContext); ok {
			len++
		}
	}

	tst := make([]ICreate_extension_opt_itemContext, len)
	i := 0
	for _, ctx := range children {
		if t, ok := ctx.(ICreate_extension_opt_itemContext); ok {
			tst[i] = t.(ICreate_extension_opt_itemContext)
			i++
		}
	}

	return tst
}

func (s *Create_extension_opt_listContext) Create_extension_opt_item(i int) ICreate_extension_opt_itemContext {
	var t antlr.RuleContext
	j := 0
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ICreate_extension_opt_itemContext); ok {
			if j == i {
				t = ctx.(antlr.RuleContext)
				break
			}
			j++
		}
	}

	if t == nil {
		return nil
	}

	return t.(ICreate_extension_opt_itemContext)
}

func (s *Create_extension_opt_listContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Create_extension_opt_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Create_extension_opt_listContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterCreate_extension_opt_list(s)
	}
}

func (s *Create_extension_opt_listContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitCreate_extension_opt_list(s)
	}
}

func (s *Create_extension_opt_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitCreate_extension_opt_list(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Create_extension_opt_list() (localctx ICreate_extension_opt_listContext) {
	localctx = NewCreate_extension_opt_listContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 318, PostgreSQLParserRULE_create_extension_opt_list)
	var _la int

	p.EnterOuterAlt(localctx, 1)
	p.SetState(3416)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}
	_la = p.GetTokenStream().LA(1)

	for _la == PostgreSQLParserFROM || _la == PostgreSQLParserCASCADE || _la == PostgreSQLParserSCHEMA || _la == PostgreSQLParserVERSION_P {
		{
			p.SetState(3413)
			p.Create_extension_opt_item()
		}

		p.SetState(3418)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}
		_la = p.GetTokenStream().LA(1)
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// ICreate_extension_opt_itemContext is an interface to support dynamic dispatch.
type ICreate_extension_opt_itemContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	SCHEMA() antlr.TerminalNode
	Name() INameContext
	VERSION_P() antlr.TerminalNode
	Nonreservedword_or_sconst() INonreservedword_or_sconstContext
	FROM() antlr.TerminalNode
	CASCADE() antlr.TerminalNode

	// IsCreate_extension_opt_itemContext differentiates from other interfaces.
	IsCreate_extension_opt_itemContext()
}

type Create_extension_opt_itemContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyCreate_extension_opt_itemContext() *Create_extension_opt_itemContext {
	var p = new(Create_extension_opt_itemContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_create_extension_opt_item
	return p
}

func InitEmptyCreate_extension_opt_itemContext(p *Create_extension_opt_itemContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_create_extension_opt_item
}

func (*Create_extension_opt_itemContext) IsCreate_extension_opt_itemContext() {}

func NewCreate_extension_opt_itemContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_extension_opt_itemContext {
	var p = new(Create_extension_opt_itemContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_create_extension_opt_item

	return p
}

func (s *Create_extension_opt_itemContext) GetParser() antlr.Parser { return s.parser }

func (s *Create_extension_opt_itemContext) SCHEMA() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserSCHEMA, 0)
}

func (s *Create_extension_opt_itemContext) Name() INameContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(INameContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(INameContext)
}

func (s *Create_extension_opt_itemContext) VERSION_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserVERSION_P, 0)
}

func (s *Create_extension_opt_itemContext) Nonreservedword_or_sconst() INonreservedword_or_sconstContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(INonreservedword_or_sconstContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(INonreservedword_or_sconstContext)
}

func (s *Create_extension_opt_itemContext) FROM() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserFROM, 0)
}

func (s *Create_extension_opt_itemContext) CASCADE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCASCADE, 0)
}

func (s *Create_extension_opt_itemContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Create_extension_opt_itemContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Create_extension_opt_itemContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterCreate_extension_opt_item(s)
	}
}

func (s *Create_extension_opt_itemContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitCreate_extension_opt_item(s)
	}
}

func (s *Create_extension_opt_itemContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitCreate_extension_opt_item(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Create_extension_opt_item() (localctx ICreate_extension_opt_itemContext) {
	localctx = NewCreate_extension_opt_itemContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 320, PostgreSQLParserRULE_create_extension_opt_item)
	p.SetState(3426)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetTokenStream().LA(1) {
	case PostgreSQLParserSCHEMA:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(3419)
			p.Match(PostgreSQLParserSCHEMA)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(3420)
			p.Name()
		}

	case PostgreSQLParserVERSION_P:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(3421)
			p.Match(PostgreSQLParserVERSION_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(3422)
			p.Nonreservedword_or_sconst()
		}

	case PostgreSQLParserFROM:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(3423)
			p.Match(PostgreSQLParserFROM)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(3424)
			p.Nonreservedword_or_sconst()
		}

	case PostgreSQLParserCASCADE:
		p.EnterOuterAlt(localctx, 4)
		{
			p.SetState(3425)
			p.Match(PostgreSQLParserCASCADE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	default:
		p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IAlterextensionstmtContext is an interface to support dynamic dispatch.
type IAlterextensionstmtContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	ALTER() antlr.TerminalNode
	EXTENSION() antlr.TerminalNode
	Name() INameContext
	UPDATE() antlr.TerminalNode
	Alter_extension_opt_list() IAlter_extension_opt_listContext

	// IsAlterextensionstmtContext differentiates from other interfaces.
	IsAlterextensionstmtContext()
}

type AlterextensionstmtContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyAlterextensionstmtContext() *AlterextensionstmtContext {
	var p = new(AlterextensionstmtContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_alterextensionstmt
	return p
}

func InitEmptyAlterextensionstmtContext(p *AlterextensionstmtContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_alterextensionstmt
}

func (*AlterextensionstmtContext) IsAlterextensionstmtContext() {}

func NewAlterextensionstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AlterextensionstmtContext {
	var p = new(AlterextensionstmtContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_alterextensionstmt

	return p
}

func (s *AlterextensionstmtContext) GetParser() antlr.Parser { return s.parser }

func (s *AlterextensionstmtContext) ALTER() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserALTER, 0)
}

func (s *AlterextensionstmtContext) EXTENSION() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserEXTENSION, 0)
}

func (s *AlterextensionstmtContext) Name() INameContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(INameContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(INameContext)
}

func (s *AlterextensionstmtContext) UPDATE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserUPDATE, 0)
}

func (s *AlterextensionstmtContext) Alter_extension_opt_list() IAlter_extension_opt_listContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IAlter_extension_opt_listContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IAlter_extension_opt_listContext)
}

func (s *AlterextensionstmtContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *AlterextensionstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *AlterextensionstmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterAlterextensionstmt(s)
	}
}

func (s *AlterextensionstmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitAlterextensionstmt(s)
	}
}

func (s *AlterextensionstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitAlterextensionstmt(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Alterextensionstmt() (localctx IAlterextensionstmtContext) {
	localctx = NewAlterextensionstmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 322, PostgreSQLParserRULE_alterextensionstmt)
	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(3428)
		p.Match(PostgreSQLParserALTER)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(3429)
		p.Match(PostgreSQLParserEXTENSION)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(3430)
		p.Name()
	}
	{
		p.SetState(3431)
		p.Match(PostgreSQLParserUPDATE)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(3432)
		p.Alter_extension_opt_list()
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IAlter_extension_opt_listContext is an interface to support dynamic dispatch.
type IAlter_extension_opt_listContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	AllAlter_extension_opt_item() []IAlter_extension_opt_itemContext
	Alter_extension_opt_item(i int) IAlter_extension_opt_itemContext

	// IsAlter_extension_opt_listContext differentiates from other interfaces.
	IsAlter_extension_opt_listContext()
}

type Alter_extension_opt_listContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyAlter_extension_opt_listContext() *Alter_extension_opt_listContext {
	var p = new(Alter_extension_opt_listContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_alter_extension_opt_list
	return p
}

func InitEmptyAlter_extension_opt_listContext(p *Alter_extension_opt_listContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_alter_extension_opt_list
}

func (*Alter_extension_opt_listContext) IsAlter_extension_opt_listContext() {}

func NewAlter_extension_opt_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_extension_opt_listContext {
	var p = new(Alter_extension_opt_listContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_alter_extension_opt_list

	return p
}

func (s *Alter_extension_opt_listContext) GetParser() antlr.Parser { return s.parser }

func (s *Alter_extension_opt_listContext) AllAlter_extension_opt_item() []IAlter_extension_opt_itemContext {
	children := s.GetChildren()
	len := 0
	for _, ctx := range children {
		if _, ok := ctx.(IAlter_extension_opt_itemContext); ok {
			len++
		}
	}

	tst := make([]IAlter_extension_opt_itemContext, len)
	i := 0
	for _, ctx := range children {
		if t, ok := ctx.(IAlter_extension_opt_itemContext); ok {
			tst[i] = t.(IAlter_extension_opt_itemContext)
			i++
		}
	}

	return tst
}

func (s *Alter_extension_opt_listContext) Alter_extension_opt_item(i int) IAlter_extension_opt_itemContext {
	var t antlr.RuleContext
	j := 0
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IAlter_extension_opt_itemContext); ok {
			if j == i {
				t = ctx.(antlr.RuleContext)
				break
			}
			j++
		}
	}

	if t == nil {
		return nil
	}

	return t.(IAlter_extension_opt_itemContext)
}

func (s *Alter_extension_opt_listContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Alter_extension_opt_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Alter_extension_opt_listContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterAlter_extension_opt_list(s)
	}
}

func (s *Alter_extension_opt_listContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitAlter_extension_opt_list(s)
	}
}

func (s *Alter_extension_opt_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitAlter_extension_opt_list(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Alter_extension_opt_list() (localctx IAlter_extension_opt_listContext) {
	localctx = NewAlter_extension_opt_listContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 324, PostgreSQLParserRULE_alter_extension_opt_list)
	var _la int

	p.EnterOuterAlt(localctx, 1)
	p.SetState(3437)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}
	_la = p.GetTokenStream().LA(1)

	for _la == PostgreSQLParserTO {
		{
			p.SetState(3434)
			p.Alter_extension_opt_item()
		}

		p.SetState(3439)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}
		_la = p.GetTokenStream().LA(1)
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IAlter_extension_opt_itemContext is an interface to support dynamic dispatch.
type IAlter_extension_opt_itemContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	TO() antlr.TerminalNode
	Nonreservedword_or_sconst() INonreservedword_or_sconstContext

	// IsAlter_extension_opt_itemContext differentiates from other interfaces.
	IsAlter_extension_opt_itemContext()
}

type Alter_extension_opt_itemContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyAlter_extension_opt_itemContext() *Alter_extension_opt_itemContext {
	var p = new(Alter_extension_opt_itemContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_alter_extension_opt_item
	return p
}

func InitEmptyAlter_extension_opt_itemContext(p *Alter_extension_opt_itemContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_alter_extension_opt_item
}

func (*Alter_extension_opt_itemContext) IsAlter_extension_opt_itemContext() {}

func NewAlter_extension_opt_itemContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_extension_opt_itemContext {
	var p = new(Alter_extension_opt_itemContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_alter_extension_opt_item

	return p
}

func (s *Alter_extension_opt_itemContext) GetParser() antlr.Parser { return s.parser }

func (s *Alter_extension_opt_itemContext) TO() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserTO, 0)
}

func (s *Alter_extension_opt_itemContext) Nonreservedword_or_sconst() INonreservedword_or_sconstContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(INonreservedword_or_sconstContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(INonreservedword_or_sconstContext)
}

func (s *Alter_extension_opt_itemContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Alter_extension_opt_itemContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Alter_extension_opt_itemContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterAlter_extension_opt_item(s)
	}
}

func (s *Alter_extension_opt_itemContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitAlter_extension_opt_item(s)
	}
}

func (s *Alter_extension_opt_itemContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitAlter_extension_opt_item(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Alter_extension_opt_item() (localctx IAlter_extension_opt_itemContext) {
	localctx = NewAlter_extension_opt_itemContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 326, PostgreSQLParserRULE_alter_extension_opt_item)
	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(3440)
		p.Match(PostgreSQLParserTO)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(3441)
		p.Nonreservedword_or_sconst()
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IAlterextensioncontentsstmtContext is an interface to support dynamic dispatch.
type IAlterextensioncontentsstmtContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	ALTER() antlr.TerminalNode
	EXTENSION() antlr.TerminalNode
	AllName() []INameContext
	Name(i int) INameContext
	Add_drop() IAdd_dropContext
	Object_type_name() IObject_type_nameContext
	Object_type_any_name() IObject_type_any_nameContext
	Any_name() IAny_nameContext
	AGGREGATE() antlr.TerminalNode
	Aggregate_with_argtypes() IAggregate_with_argtypesContext
	CAST() antlr.TerminalNode
	OPEN_PAREN() antlr.TerminalNode
	AllTypename() []ITypenameContext
	Typename(i int) ITypenameContext
	AS() antlr.TerminalNode
	CLOSE_PAREN() antlr.TerminalNode
	DOMAIN_P() antlr.TerminalNode
	FUNCTION() antlr.TerminalNode
	Function_with_argtypes() IFunction_with_argtypesContext
	OPERATOR() antlr.TerminalNode
	Operator_with_argtypes() IOperator_with_argtypesContext
	CLASS() antlr.TerminalNode
	USING() antlr.TerminalNode
	FAMILY() antlr.TerminalNode
	PROCEDURE() antlr.TerminalNode
	ROUTINE() antlr.TerminalNode
	TRANSFORM() antlr.TerminalNode
	FOR() antlr.TerminalNode
	LANGUAGE() antlr.TerminalNode
	TYPE_P() antlr.TerminalNode

	// IsAlterextensioncontentsstmtContext differentiates from other interfaces.
	IsAlterextensioncontentsstmtContext()
}

type AlterextensioncontentsstmtContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyAlterextensioncontentsstmtContext() *AlterextensioncontentsstmtContext {
	var p = new(AlterextensioncontentsstmtContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_alterextensioncontentsstmt
	return p
}

func InitEmptyAlterextensioncontentsstmtContext(p *AlterextensioncontentsstmtContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_alterextensioncontentsstmt
}

func (*AlterextensioncontentsstmtContext) IsAlterextensioncontentsstmtContext() {}

func NewAlterextensioncontentsstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AlterextensioncontentsstmtContext {
	var p = new(AlterextensioncontentsstmtContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_alterextensioncontentsstmt

	return p
}

func (s *AlterextensioncontentsstmtContext) GetParser() antlr.Parser { return s.parser }

func (s *AlterextensioncontentsstmtContext) ALTER() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserALTER, 0)
}

func (s *AlterextensioncontentsstmtContext) EXTENSION() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserEXTENSION, 0)
}

func (s *AlterextensioncontentsstmtContext) AllName() []INameContext {
	children := s.GetChildren()
	len := 0
	for _, ctx := range children {
		if _, ok := ctx.(INameContext); ok {
			len++
		}
	}

	tst := make([]INameContext, len)
	i := 0
	for _, ctx := range children {
		if t, ok := ctx.(INameContext); ok {
			tst[i] = t.(INameContext)
			i++
		}
	}

	return tst
}

func (s *AlterextensioncontentsstmtContext) Name(i int) INameContext {
	var t antlr.RuleContext
	j := 0
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(INameContext); ok {
			if j == i {
				t = ctx.(antlr.RuleContext)
				break
			}
			j++
		}
	}

	if t == nil {
		return nil
	}

	return t.(INameContext)
}

func (s *AlterextensioncontentsstmtContext) Add_drop() IAdd_dropContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IAdd_dropContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IAdd_dropContext)
}

func (s *AlterextensioncontentsstmtContext) Object_type_name() IObject_type_nameContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IObject_type_nameContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IObject_type_nameContext)
}

func (s *AlterextensioncontentsstmtContext) Object_type_any_name() IObject_type_any_nameContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IObject_type_any_nameContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IObject_type_any_nameContext)
}

func (s *AlterextensioncontentsstmtContext) Any_name() IAny_nameContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IAny_nameContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IAny_nameContext)
}

func (s *AlterextensioncontentsstmtContext) AGGREGATE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserAGGREGATE, 0)
}

func (s *AlterextensioncontentsstmtContext) Aggregate_with_argtypes() IAggregate_with_argtypesContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IAggregate_with_argtypesContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IAggregate_with_argtypesContext)
}

func (s *AlterextensioncontentsstmtContext) CAST() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCAST, 0)
}

func (s *AlterextensioncontentsstmtContext) OPEN_PAREN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserOPEN_PAREN, 0)
}

func (s *AlterextensioncontentsstmtContext) AllTypename() []ITypenameContext {
	children := s.GetChildren()
	len := 0
	for _, ctx := range children {
		if _, ok := ctx.(ITypenameContext); ok {
			len++
		}
	}

	tst := make([]ITypenameContext, len)
	i := 0
	for _, ctx := range children {
		if t, ok := ctx.(ITypenameContext); ok {
			tst[i] = t.(ITypenameContext)
			i++
		}
	}

	return tst
}

func (s *AlterextensioncontentsstmtContext) Typename(i int) ITypenameContext {
	var t antlr.RuleContext
	j := 0
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ITypenameContext); ok {
			if j == i {
				t = ctx.(antlr.RuleContext)
				break
			}
			j++
		}
	}

	if t == nil {
		return nil
	}

	return t.(ITypenameContext)
}

func (s *AlterextensioncontentsstmtContext) AS() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserAS, 0)
}

func (s *AlterextensioncontentsstmtContext) CLOSE_PAREN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCLOSE_PAREN, 0)
}

func (s *AlterextensioncontentsstmtContext) DOMAIN_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserDOMAIN_P, 0)
}

func (s *AlterextensioncontentsstmtContext) FUNCTION() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserFUNCTION, 0)
}

func (s *AlterextensioncontentsstmtContext) Function_with_argtypes() IFunction_with_argtypesContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IFunction_with_argtypesContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IFunction_with_argtypesContext)
}

func (s *AlterextensioncontentsstmtContext) OPERATOR() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserOPERATOR, 0)
}

func (s *AlterextensioncontentsstmtContext) Operator_with_argtypes() IOperator_with_argtypesContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOperator_with_argtypesContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOperator_with_argtypesContext)
}

func (s *AlterextensioncontentsstmtContext) CLASS() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCLASS, 0)
}

func (s *AlterextensioncontentsstmtContext) USING() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserUSING, 0)
}

func (s *AlterextensioncontentsstmtContext) FAMILY() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserFAMILY, 0)
}

func (s *AlterextensioncontentsstmtContext) PROCEDURE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserPROCEDURE, 0)
}

func (s *AlterextensioncontentsstmtContext) ROUTINE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserROUTINE, 0)
}

func (s *AlterextensioncontentsstmtContext) TRANSFORM() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserTRANSFORM, 0)
}

func (s *AlterextensioncontentsstmtContext) FOR() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserFOR, 0)
}

func (s *AlterextensioncontentsstmtContext) LANGUAGE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserLANGUAGE, 0)
}

func (s *AlterextensioncontentsstmtContext) TYPE_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserTYPE_P, 0)
}

func (s *AlterextensioncontentsstmtContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *AlterextensioncontentsstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *AlterextensioncontentsstmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterAlterextensioncontentsstmt(s)
	}
}

func (s *AlterextensioncontentsstmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitAlterextensioncontentsstmt(s)
	}
}

func (s *AlterextensioncontentsstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitAlterextensioncontentsstmt(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Alterextensioncontentsstmt() (localctx IAlterextensioncontentsstmtContext) {
	localctx = NewAlterextensioncontentsstmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 328, PostgreSQLParserRULE_alterextensioncontentsstmt)
	p.SetState(3547)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 152, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(3443)
			p.Match(PostgreSQLParserALTER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(3444)
			p.Match(PostgreSQLParserEXTENSION)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(3445)
			p.Name()
		}
		{
			p.SetState(3446)
			p.Add_drop()
		}
		{
			p.SetState(3447)
			p.Object_type_name()
		}
		{
			p.SetState(3448)
			p.Name()
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(3450)
			p.Match(PostgreSQLParserALTER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(3451)
			p.Match(PostgreSQLParserEXTENSION)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(3452)
			p.Name()
		}
		{
			p.SetState(3453)
			p.Add_drop()
		}
		{
			p.SetState(3454)
			p.Object_type_any_name()
		}
		{
			p.SetState(3455)
			p.Any_name()
		}

	case 3:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(3457)
			p.Match(PostgreSQLParserALTER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(3458)
			p.Match(PostgreSQLParserEXTENSION)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(3459)
			p.Name()
		}
		{
			p.SetState(3460)
			p.Add_drop()
		}
		{
			p.SetState(3461)
			p.Match(PostgreSQLParserAGGREGATE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(3462)
			p.Aggregate_with_argtypes()
		}

	case 4:
		p.EnterOuterAlt(localctx, 4)
		{
			p.SetState(3464)
			p.Match(PostgreSQLParserALTER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(3465)
			p.Match(PostgreSQLParserEXTENSION)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(3466)
			p.Name()
		}
		{
			p.SetState(3467)
			p.Add_drop()
		}
		{
			p.SetState(3468)
			p.Match(PostgreSQLParserCAST)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(3469)
			p.Match(PostgreSQLParserOPEN_PAREN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(3470)
			p.Typename()
		}
		{
			p.SetState(3471)
			p.Match(PostgreSQLParserAS)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(3472)
			p.Typename()
		}
		{
			p.SetState(3473)
			p.Match(PostgreSQLParserCLOSE_PAREN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 5:
		p.EnterOuterAlt(localctx, 5)
		{
			p.SetState(3475)
			p.Match(PostgreSQLParserALTER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(3476)
			p.Match(PostgreSQLParserEXTENSION)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(3477)
			p.Name()
		}
		{
			p.SetState(3478)
			p.Add_drop()
		}
		{
			p.SetState(3479)
			p.Match(PostgreSQLParserDOMAIN_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(3480)
			p.Typename()
		}

	case 6:
		p.EnterOuterAlt(localctx, 6)
		{
			p.SetState(3482)
			p.Match(PostgreSQLParserALTER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(3483)
			p.Match(PostgreSQLParserEXTENSION)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(3484)
			p.Name()
		}
		{
			p.SetState(3485)
			p.Add_drop()
		}
		{
			p.SetState(3486)
			p.Match(PostgreSQLParserFUNCTION)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(3487)
			p.Function_with_argtypes()
		}

	case 7:
		p.EnterOuterAlt(localctx, 7)
		{
			p.SetState(3489)
			p.Match(PostgreSQLParserALTER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(3490)
			p.Match(PostgreSQLParserEXTENSION)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(3491)
			p.Name()
		}
		{
			p.SetState(3492)
			p.Add_drop()
		}
		{
			p.SetState(3493)
			p.Match(PostgreSQLParserOPERATOR)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(3494)
			p.Operator_with_argtypes()
		}

	case 8:
		p.EnterOuterAlt(localctx, 8)
		{
			p.SetState(3496)
			p.Match(PostgreSQLParserALTER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(3497)
			p.Match(PostgreSQLParserEXTENSION)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(3498)
			p.Name()
		}
		{
			p.SetState(3499)
			p.Add_drop()
		}
		{
			p.SetState(3500)
			p.Match(PostgreSQLParserOPERATOR)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(3501)
			p.Match(PostgreSQLParserCLASS)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(3502)
			p.Any_name()
		}
		{
			p.SetState(3503)
			p.Match(PostgreSQLParserUSING)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(3504)
			p.Name()
		}

	case 9:
		p.EnterOuterAlt(localctx, 9)
		{
			p.SetState(3506)
			p.Match(PostgreSQLParserALTER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(3507)
			p.Match(PostgreSQLParserEXTENSION)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(3508)
			p.Name()
		}
		{
			p.SetState(3509)
			p.Add_drop()
		}
		{
			p.SetState(3510)
			p.Match(PostgreSQLParserOPERATOR)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(3511)
			p.Match(PostgreSQLParserFAMILY)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(3512)
			p.Any_name()
		}
		{
			p.SetState(3513)
			p.Match(PostgreSQLParserUSING)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(3514)
			p.Name()
		}

	case 10:
		p.EnterOuterAlt(localctx, 10)
		{
			p.SetState(3516)
			p.Match(PostgreSQLParserALTER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(3517)
			p.Match(PostgreSQLParserEXTENSION)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(3518)
			p.Name()
		}
		{
			p.SetState(3519)
			p.Add_drop()
		}
		{
			p.SetState(3520)
			p.Match(PostgreSQLParserPROCEDURE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(3521)
			p.Function_with_argtypes()
		}

	case 11:
		p.EnterOuterAlt(localctx, 11)
		{
			p.SetState(3523)
			p.Match(PostgreSQLParserALTER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(3524)
			p.Match(PostgreSQLParserEXTENSION)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(3525)
			p.Name()
		}
		{
			p.SetState(3526)
			p.Add_drop()
		}
		{
			p.SetState(3527)
			p.Match(PostgreSQLParserROUTINE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(3528)
			p.Function_with_argtypes()
		}

	case 12:
		p.EnterOuterAlt(localctx, 12)
		{
			p.SetState(3530)
			p.Match(PostgreSQLParserALTER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(3531)
			p.Match(PostgreSQLParserEXTENSION)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(3532)
			p.Name()
		}
		{
			p.SetState(3533)
			p.Add_drop()
		}
		{
			p.SetState(3534)
			p.Match(PostgreSQLParserTRANSFORM)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(3535)
			p.Match(PostgreSQLParserFOR)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(3536)
			p.Typename()
		}
		{
			p.SetState(3537)
			p.Match(PostgreSQLParserLANGUAGE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(3538)
			p.Name()
		}

	case 13:
		p.EnterOuterAlt(localctx, 13)
		{
			p.SetState(3540)
			p.Match(PostgreSQLParserALTER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(3541)
			p.Match(PostgreSQLParserEXTENSION)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(3542)
			p.Name()
		}
		{
			p.SetState(3543)
			p.Add_drop()
		}
		{
			p.SetState(3544)
			p.Match(PostgreSQLParserTYPE_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(3545)
			p.Typename()
		}

	case antlr.ATNInvalidAltNumber:
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// ICreatefdwstmtContext is an interface to support dynamic dispatch.
type ICreatefdwstmtContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	CREATE() antlr.TerminalNode
	FOREIGN() antlr.TerminalNode
	DATA_P() antlr.TerminalNode
	WRAPPER() antlr.TerminalNode
	Name() INameContext
	Opt_fdw_options() IOpt_fdw_optionsContext
	Create_generic_options() ICreate_generic_optionsContext

	// IsCreatefdwstmtContext differentiates from other interfaces.
	IsCreatefdwstmtContext()
}

type CreatefdwstmtContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyCreatefdwstmtContext() *CreatefdwstmtContext {
	var p = new(CreatefdwstmtContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_createfdwstmt
	return p
}

func InitEmptyCreatefdwstmtContext(p *CreatefdwstmtContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_createfdwstmt
}

func (*CreatefdwstmtContext) IsCreatefdwstmtContext() {}

func NewCreatefdwstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CreatefdwstmtContext {
	var p = new(CreatefdwstmtContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_createfdwstmt

	return p
}

func (s *CreatefdwstmtContext) GetParser() antlr.Parser { return s.parser }

func (s *CreatefdwstmtContext) CREATE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCREATE, 0)
}

func (s *CreatefdwstmtContext) FOREIGN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserFOREIGN, 0)
}

func (s *CreatefdwstmtContext) DATA_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserDATA_P, 0)
}

func (s *CreatefdwstmtContext) WRAPPER() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserWRAPPER, 0)
}

func (s *CreatefdwstmtContext) Name() INameContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(INameContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(INameContext)
}

func (s *CreatefdwstmtContext) Opt_fdw_options() IOpt_fdw_optionsContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOpt_fdw_optionsContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOpt_fdw_optionsContext)
}

func (s *CreatefdwstmtContext) Create_generic_options() ICreate_generic_optionsContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ICreate_generic_optionsContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ICreate_generic_optionsContext)
}

func (s *CreatefdwstmtContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *CreatefdwstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *CreatefdwstmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterCreatefdwstmt(s)
	}
}

func (s *CreatefdwstmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitCreatefdwstmt(s)
	}
}

func (s *CreatefdwstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitCreatefdwstmt(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Createfdwstmt() (localctx ICreatefdwstmtContext) {
	localctx = NewCreatefdwstmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 330, PostgreSQLParserRULE_createfdwstmt)
	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(3549)
		p.Match(PostgreSQLParserCREATE)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(3550)
		p.Match(PostgreSQLParserFOREIGN)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(3551)
		p.Match(PostgreSQLParserDATA_P)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(3552)
		p.Match(PostgreSQLParserWRAPPER)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(3553)
		p.Name()
	}
	{
		p.SetState(3554)
		p.Opt_fdw_options()
	}
	{
		p.SetState(3555)
		p.Create_generic_options()
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IFdw_optionContext is an interface to support dynamic dispatch.
type IFdw_optionContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	HANDLER() antlr.TerminalNode
	Handler_name() IHandler_nameContext
	NO() antlr.TerminalNode
	VALIDATOR() antlr.TerminalNode

	// IsFdw_optionContext differentiates from other interfaces.
	IsFdw_optionContext()
}

type Fdw_optionContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyFdw_optionContext() *Fdw_optionContext {
	var p = new(Fdw_optionContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_fdw_option
	return p
}

func InitEmptyFdw_optionContext(p *Fdw_optionContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_fdw_option
}

func (*Fdw_optionContext) IsFdw_optionContext() {}

func NewFdw_optionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Fdw_optionContext {
	var p = new(Fdw_optionContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_fdw_option

	return p
}

func (s *Fdw_optionContext) GetParser() antlr.Parser { return s.parser }

func (s *Fdw_optionContext) HANDLER() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserHANDLER, 0)
}

func (s *Fdw_optionContext) Handler_name() IHandler_nameContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IHandler_nameContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IHandler_nameContext)
}

func (s *Fdw_optionContext) NO() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserNO, 0)
}

func (s *Fdw_optionContext) VALIDATOR() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserVALIDATOR, 0)
}

func (s *Fdw_optionContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Fdw_optionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Fdw_optionContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterFdw_option(s)
	}
}

func (s *Fdw_optionContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitFdw_option(s)
	}
}

func (s *Fdw_optionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitFdw_option(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Fdw_option() (localctx IFdw_optionContext) {
	localctx = NewFdw_optionContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 332, PostgreSQLParserRULE_fdw_option)
	p.SetState(3565)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 153, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(3557)
			p.Match(PostgreSQLParserHANDLER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(3558)
			p.Handler_name()
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(3559)
			p.Match(PostgreSQLParserNO)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(3560)
			p.Match(PostgreSQLParserHANDLER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 3:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(3561)
			p.Match(PostgreSQLParserVALIDATOR)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(3562)
			p.Handler_name()
		}

	case 4:
		p.EnterOuterAlt(localctx, 4)
		{
			p.SetState(3563)
			p.Match(PostgreSQLParserNO)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(3564)
			p.Match(PostgreSQLParserVALIDATOR)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case antlr.ATNInvalidAltNumber:
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IFdw_optionsContext is an interface to support dynamic dispatch.
type IFdw_optionsContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	AllFdw_option() []IFdw_optionContext
	Fdw_option(i int) IFdw_optionContext

	// IsFdw_optionsContext differentiates from other interfaces.
	IsFdw_optionsContext()
}

type Fdw_optionsContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyFdw_optionsContext() *Fdw_optionsContext {
	var p = new(Fdw_optionsContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_fdw_options
	return p
}

func InitEmptyFdw_optionsContext(p *Fdw_optionsContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_fdw_options
}

func (*Fdw_optionsContext) IsFdw_optionsContext() {}

func NewFdw_optionsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Fdw_optionsContext {
	var p = new(Fdw_optionsContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_fdw_options

	return p
}

func (s *Fdw_optionsContext) GetParser() antlr.Parser { return s.parser }

func (s *Fdw_optionsContext) AllFdw_option() []IFdw_optionContext {
	children := s.GetChildren()
	len := 0
	for _, ctx := range children {
		if _, ok := ctx.(IFdw_optionContext); ok {
			len++
		}
	}

	tst := make([]IFdw_optionContext, len)
	i := 0
	for _, ctx := range children {
		if t, ok := ctx.(IFdw_optionContext); ok {
			tst[i] = t.(IFdw_optionContext)
			i++
		}
	}

	return tst
}

func (s *Fdw_optionsContext) Fdw_option(i int) IFdw_optionContext {
	var t antlr.RuleContext
	j := 0
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IFdw_optionContext); ok {
			if j == i {
				t = ctx.(antlr.RuleContext)
				break
			}
			j++
		}
	}

	if t == nil {
		return nil
	}

	return t.(IFdw_optionContext)
}

func (s *Fdw_optionsContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Fdw_optionsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Fdw_optionsContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterFdw_options(s)
	}
}

func (s *Fdw_optionsContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitFdw_options(s)
	}
}

func (s *Fdw_optionsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitFdw_options(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Fdw_options() (localctx IFdw_optionsContext) {
	localctx = NewFdw_optionsContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 334, PostgreSQLParserRULE_fdw_options)
	var _la int

	p.EnterOuterAlt(localctx, 1)
	p.SetState(3568)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}
	_la = p.GetTokenStream().LA(1)

	for ok := true; ok; ok = _la == PostgreSQLParserHANDLER || _la == PostgreSQLParserNO || _la == PostgreSQLParserVALIDATOR {
		{
			p.SetState(3567)
			p.Fdw_option()
		}

		p.SetState(3570)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}
		_la = p.GetTokenStream().LA(1)
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IOpt_fdw_optionsContext is an interface to support dynamic dispatch.
type IOpt_fdw_optionsContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Fdw_options() IFdw_optionsContext

	// IsOpt_fdw_optionsContext differentiates from other interfaces.
	IsOpt_fdw_optionsContext()
}

type Opt_fdw_optionsContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyOpt_fdw_optionsContext() *Opt_fdw_optionsContext {
	var p = new(Opt_fdw_optionsContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opt_fdw_options
	return p
}

func InitEmptyOpt_fdw_optionsContext(p *Opt_fdw_optionsContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opt_fdw_options
}

func (*Opt_fdw_optionsContext) IsOpt_fdw_optionsContext() {}

func NewOpt_fdw_optionsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_fdw_optionsContext {
	var p = new(Opt_fdw_optionsContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_opt_fdw_options

	return p
}

func (s *Opt_fdw_optionsContext) GetParser() antlr.Parser { return s.parser }

func (s *Opt_fdw_optionsContext) Fdw_options() IFdw_optionsContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IFdw_optionsContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IFdw_optionsContext)
}

func (s *Opt_fdw_optionsContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Opt_fdw_optionsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Opt_fdw_optionsContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterOpt_fdw_options(s)
	}
}

func (s *Opt_fdw_optionsContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitOpt_fdw_options(s)
	}
}

func (s *Opt_fdw_optionsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitOpt_fdw_options(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Opt_fdw_options() (localctx IOpt_fdw_optionsContext) {
	localctx = NewOpt_fdw_optionsContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 336, PostgreSQLParserRULE_opt_fdw_options)
	p.SetState(3574)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetTokenStream().LA(1) {
	case PostgreSQLParserHANDLER, PostgreSQLParserNO, PostgreSQLParserVALIDATOR:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(3572)
			p.Fdw_options()
		}

	case PostgreSQLParserEOF, PostgreSQLParserOPEN_PAREN, PostgreSQLParserSEMI, PostgreSQLParserANALYSE, PostgreSQLParserANALYZE, PostgreSQLParserCREATE, PostgreSQLParserDO, PostgreSQLParserFETCH, PostgreSQLParserGRANT, PostgreSQLParserINTO, PostgreSQLParserSELECT, PostgreSQLParserTABLE, PostgreSQLParserWITH, PostgreSQLParserABORT_P, PostgreSQLParserALTER, PostgreSQLParserBEGIN_P, PostgreSQLParserCHECKPOINT, PostgreSQLParserCLOSE, PostgreSQLParserCLUSTER, PostgreSQLParserCOMMENT, PostgreSQLParserCOMMIT, PostgreSQLParserCOPY, PostgreSQLParserDEALLOCATE, PostgreSQLParserDECLARE, PostgreSQLParserDELETE_P, PostgreSQLParserDISCARD, PostgreSQLParserDROP, PostgreSQLParserEXECUTE, PostgreSQLParserEXPLAIN, PostgreSQLParserINSERT, PostgreSQLParserLISTEN, PostgreSQLParserLOAD, PostgreSQLParserLOCK_P, PostgreSQLParserMERGE, PostgreSQLParserMOVE, PostgreSQLParserNOTIFY, PostgreSQLParserOPTIONS, PostgreSQLParserPREPARE, PostgreSQLParserREASSIGN, PostgreSQLParserREFRESH, PostgreSQLParserREINDEX, PostgreSQLParserRELEASE, PostgreSQLParserRESET, PostgreSQLParserREVOKE, PostgreSQLParserROLLBACK, PostgreSQLParserSAVEPOINT, PostgreSQLParserSECURITY, PostgreSQLParserSET, PostgreSQLParserSHOW, PostgreSQLParserSTART, PostgreSQLParserTRUNCATE, PostgreSQLParserUNLISTEN, PostgreSQLParserUPDATE, PostgreSQLParserVACUUM, PostgreSQLParserVALUES, PostgreSQLParserCALL, PostgreSQLParserIMPORT_P, PostgreSQLParserEND_P, PostgreSQLParserMetaCommand:
		p.EnterOuterAlt(localctx, 2)

	default:
		p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IAlterfdwstmtContext is an interface to support dynamic dispatch.
type IAlterfdwstmtContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	ALTER() antlr.TerminalNode
	FOREIGN() antlr.TerminalNode
	DATA_P() antlr.TerminalNode
	WRAPPER() antlr.TerminalNode
	Name() INameContext
	Opt_fdw_options() IOpt_fdw_optionsContext
	Alter_generic_options() IAlter_generic_optionsContext
	Fdw_options() IFdw_optionsContext

	// IsAlterfdwstmtContext differentiates from other interfaces.
	IsAlterfdwstmtContext()
}

type AlterfdwstmtContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyAlterfdwstmtContext() *AlterfdwstmtContext {
	var p = new(AlterfdwstmtContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_alterfdwstmt
	return p
}

func InitEmptyAlterfdwstmtContext(p *AlterfdwstmtContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_alterfdwstmt
}

func (*AlterfdwstmtContext) IsAlterfdwstmtContext() {}

func NewAlterfdwstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AlterfdwstmtContext {
	var p = new(AlterfdwstmtContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_alterfdwstmt

	return p
}

func (s *AlterfdwstmtContext) GetParser() antlr.Parser { return s.parser }

func (s *AlterfdwstmtContext) ALTER() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserALTER, 0)
}

func (s *AlterfdwstmtContext) FOREIGN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserFOREIGN, 0)
}

func (s *AlterfdwstmtContext) DATA_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserDATA_P, 0)
}

func (s *AlterfdwstmtContext) WRAPPER() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserWRAPPER, 0)
}

func (s *AlterfdwstmtContext) Name() INameContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(INameContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(INameContext)
}

func (s *AlterfdwstmtContext) Opt_fdw_options() IOpt_fdw_optionsContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOpt_fdw_optionsContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOpt_fdw_optionsContext)
}

func (s *AlterfdwstmtContext) Alter_generic_options() IAlter_generic_optionsContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IAlter_generic_optionsContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IAlter_generic_optionsContext)
}

func (s *AlterfdwstmtContext) Fdw_options() IFdw_optionsContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IFdw_optionsContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IFdw_optionsContext)
}

func (s *AlterfdwstmtContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *AlterfdwstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *AlterfdwstmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterAlterfdwstmt(s)
	}
}

func (s *AlterfdwstmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitAlterfdwstmt(s)
	}
}

func (s *AlterfdwstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitAlterfdwstmt(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Alterfdwstmt() (localctx IAlterfdwstmtContext) {
	localctx = NewAlterfdwstmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 338, PostgreSQLParserRULE_alterfdwstmt)
	p.SetState(3591)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 156, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(3576)
			p.Match(PostgreSQLParserALTER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(3577)
			p.Match(PostgreSQLParserFOREIGN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(3578)
			p.Match(PostgreSQLParserDATA_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(3579)
			p.Match(PostgreSQLParserWRAPPER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(3580)
			p.Name()
		}
		{
			p.SetState(3581)
			p.Opt_fdw_options()
		}
		{
			p.SetState(3582)
			p.Alter_generic_options()
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(3584)
			p.Match(PostgreSQLParserALTER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(3585)
			p.Match(PostgreSQLParserFOREIGN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(3586)
			p.Match(PostgreSQLParserDATA_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(3587)
			p.Match(PostgreSQLParserWRAPPER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(3588)
			p.Name()
		}
		{
			p.SetState(3589)
			p.Fdw_options()
		}

	case antlr.ATNInvalidAltNumber:
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// ICreate_generic_optionsContext is an interface to support dynamic dispatch.
type ICreate_generic_optionsContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	OPTIONS() antlr.TerminalNode
	OPEN_PAREN() antlr.TerminalNode
	Generic_option_list() IGeneric_option_listContext
	CLOSE_PAREN() antlr.TerminalNode

	// IsCreate_generic_optionsContext differentiates from other interfaces.
	IsCreate_generic_optionsContext()
}

type Create_generic_optionsContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyCreate_generic_optionsContext() *Create_generic_optionsContext {
	var p = new(Create_generic_optionsContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_create_generic_options
	return p
}

func InitEmptyCreate_generic_optionsContext(p *Create_generic_optionsContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_create_generic_options
}

func (*Create_generic_optionsContext) IsCreate_generic_optionsContext() {}

func NewCreate_generic_optionsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_generic_optionsContext {
	var p = new(Create_generic_optionsContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_create_generic_options

	return p
}

func (s *Create_generic_optionsContext) GetParser() antlr.Parser { return s.parser }

func (s *Create_generic_optionsContext) OPTIONS() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserOPTIONS, 0)
}

func (s *Create_generic_optionsContext) OPEN_PAREN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserOPEN_PAREN, 0)
}

func (s *Create_generic_optionsContext) Generic_option_list() IGeneric_option_listContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IGeneric_option_listContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IGeneric_option_listContext)
}

func (s *Create_generic_optionsContext) CLOSE_PAREN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCLOSE_PAREN, 0)
}

func (s *Create_generic_optionsContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Create_generic_optionsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Create_generic_optionsContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterCreate_generic_options(s)
	}
}

func (s *Create_generic_optionsContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitCreate_generic_options(s)
	}
}

func (s *Create_generic_optionsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitCreate_generic_options(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Create_generic_options() (localctx ICreate_generic_optionsContext) {
	localctx = NewCreate_generic_optionsContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 340, PostgreSQLParserRULE_create_generic_options)
	p.SetState(3599)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetTokenStream().LA(1) {
	case PostgreSQLParserOPTIONS:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(3593)
			p.Match(PostgreSQLParserOPTIONS)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(3594)
			p.Match(PostgreSQLParserOPEN_PAREN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(3595)
			p.Generic_option_list()
		}
		{
			p.SetState(3596)
			p.Match(PostgreSQLParserCLOSE_PAREN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case PostgreSQLParserEOF, PostgreSQLParserOPEN_PAREN, PostgreSQLParserCLOSE_PAREN, PostgreSQLParserCOMMA, PostgreSQLParserSEMI, PostgreSQLParserANALYSE, PostgreSQLParserANALYZE, PostgreSQLParserCHECK, PostgreSQLParserCOLLATE, PostgreSQLParserCONSTRAINT, PostgreSQLParserCREATE, PostgreSQLParserDEFAULT, PostgreSQLParserDEFERRABLE, PostgreSQLParserDO, PostgreSQLParserFETCH, PostgreSQLParserGRANT, PostgreSQLParserINITIALLY, PostgreSQLParserINTO, PostgreSQLParserNOT, PostgreSQLParserNULL_P, PostgreSQLParserPRIMARY, PostgreSQLParserREFERENCES, PostgreSQLParserSELECT, PostgreSQLParserTABLE, PostgreSQLParserUNIQUE, PostgreSQLParserWITH, PostgreSQLParserABORT_P, PostgreSQLParserALTER, PostgreSQLParserBEGIN_P, PostgreSQLParserCHECKPOINT, PostgreSQLParserCLOSE, PostgreSQLParserCLUSTER, PostgreSQLParserCOMMENT, PostgreSQLParserCOMMIT, PostgreSQLParserCOPY, PostgreSQLParserDEALLOCATE, PostgreSQLParserDECLARE, PostgreSQLParserDELETE_P, PostgreSQLParserDISCARD, PostgreSQLParserDROP, PostgreSQLParserEXECUTE, PostgreSQLParserEXPLAIN, PostgreSQLParserINSERT, PostgreSQLParserLISTEN, PostgreSQLParserLOAD, PostgreSQLParserLOCK_P, PostgreSQLParserMERGE, PostgreSQLParserMOVE, PostgreSQLParserNOTIFY, PostgreSQLParserPREPARE, PostgreSQLParserREASSIGN, PostgreSQLParserREFRESH, PostgreSQLParserREINDEX, PostgreSQLParserRELEASE, PostgreSQLParserRESET, PostgreSQLParserREVOKE, PostgreSQLParserROLLBACK, PostgreSQLParserSAVEPOINT, PostgreSQLParserSECURITY, PostgreSQLParserSET, PostgreSQLParserSHOW, PostgreSQLParserSTART, PostgreSQLParserTRUNCATE, PostgreSQLParserUNLISTEN, PostgreSQLParserUPDATE, PostgreSQLParserVACUUM, PostgreSQLParserVALUES, PostgreSQLParserCALL, PostgreSQLParserGENERATED, PostgreSQLParserIMPORT_P, PostgreSQLParserEND_P, PostgreSQLParserMetaCommand:
		p.EnterOuterAlt(localctx, 2)

	default:
		p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IGeneric_option_listContext is an interface to support dynamic dispatch.
type IGeneric_option_listContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	AllGeneric_option_elem() []IGeneric_option_elemContext
	Generic_option_elem(i int) IGeneric_option_elemContext
	AllCOMMA() []antlr.TerminalNode
	COMMA(i int) antlr.TerminalNode

	// IsGeneric_option_listContext differentiates from other interfaces.
	IsGeneric_option_listContext()
}

type Generic_option_listContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyGeneric_option_listContext() *Generic_option_listContext {
	var p = new(Generic_option_listContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_generic_option_list
	return p
}

func InitEmptyGeneric_option_listContext(p *Generic_option_listContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_generic_option_list
}

func (*Generic_option_listContext) IsGeneric_option_listContext() {}

func NewGeneric_option_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Generic_option_listContext {
	var p = new(Generic_option_listContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_generic_option_list

	return p
}

func (s *Generic_option_listContext) GetParser() antlr.Parser { return s.parser }

func (s *Generic_option_listContext) AllGeneric_option_elem() []IGeneric_option_elemContext {
	children := s.GetChildren()
	len := 0
	for _, ctx := range children {
		if _, ok := ctx.(IGeneric_option_elemContext); ok {
			len++
		}
	}

	tst := make([]IGeneric_option_elemContext, len)
	i := 0
	for _, ctx := range children {
		if t, ok := ctx.(IGeneric_option_elemContext); ok {
			tst[i] = t.(IGeneric_option_elemContext)
			i++
		}
	}

	return tst
}

func (s *Generic_option_listContext) Generic_option_elem(i int) IGeneric_option_elemContext {
	var t antlr.RuleContext
	j := 0
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IGeneric_option_elemContext); ok {
			if j == i {
				t = ctx.(antlr.RuleContext)
				break
			}
			j++
		}
	}

	if t == nil {
		return nil
	}

	return t.(IGeneric_option_elemContext)
}

func (s *Generic_option_listContext) AllCOMMA() []antlr.TerminalNode {
	return s.GetTokens(PostgreSQLParserCOMMA)
}

func (s *Generic_option_listContext) COMMA(i int) antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCOMMA, i)
}

func (s *Generic_option_listContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Generic_option_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Generic_option_listContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterGeneric_option_list(s)
	}
}

func (s *Generic_option_listContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitGeneric_option_list(s)
	}
}

func (s *Generic_option_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitGeneric_option_list(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Generic_option_list() (localctx IGeneric_option_listContext) {
	localctx = NewGeneric_option_listContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 342, PostgreSQLParserRULE_generic_option_list)
	var _la int

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(3601)
		p.Generic_option_elem()
	}
	p.SetState(3606)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}
	_la = p.GetTokenStream().LA(1)

	for _la == PostgreSQLParserCOMMA {
		{
			p.SetState(3602)
			p.Match(PostgreSQLParserCOMMA)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(3603)
			p.Generic_option_elem()
		}

		p.SetState(3608)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}
		_la = p.GetTokenStream().LA(1)
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IAlter_generic_optionsContext is an interface to support dynamic dispatch.
type IAlter_generic_optionsContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	OPTIONS() antlr.TerminalNode
	OPEN_PAREN() antlr.TerminalNode
	Alter_generic_option_list() IAlter_generic_option_listContext
	CLOSE_PAREN() antlr.TerminalNode

	// IsAlter_generic_optionsContext differentiates from other interfaces.
	IsAlter_generic_optionsContext()
}

type Alter_generic_optionsContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyAlter_generic_optionsContext() *Alter_generic_optionsContext {
	var p = new(Alter_generic_optionsContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_alter_generic_options
	return p
}

func InitEmptyAlter_generic_optionsContext(p *Alter_generic_optionsContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_alter_generic_options
}

func (*Alter_generic_optionsContext) IsAlter_generic_optionsContext() {}

func NewAlter_generic_optionsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_generic_optionsContext {
	var p = new(Alter_generic_optionsContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_alter_generic_options

	return p
}

func (s *Alter_generic_optionsContext) GetParser() antlr.Parser { return s.parser }

func (s *Alter_generic_optionsContext) OPTIONS() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserOPTIONS, 0)
}

func (s *Alter_generic_optionsContext) OPEN_PAREN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserOPEN_PAREN, 0)
}

func (s *Alter_generic_optionsContext) Alter_generic_option_list() IAlter_generic_option_listContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IAlter_generic_option_listContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IAlter_generic_option_listContext)
}

func (s *Alter_generic_optionsContext) CLOSE_PAREN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCLOSE_PAREN, 0)
}

func (s *Alter_generic_optionsContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Alter_generic_optionsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Alter_generic_optionsContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterAlter_generic_options(s)
	}
}

func (s *Alter_generic_optionsContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitAlter_generic_options(s)
	}
}

func (s *Alter_generic_optionsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitAlter_generic_options(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Alter_generic_options() (localctx IAlter_generic_optionsContext) {
	localctx = NewAlter_generic_optionsContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 344, PostgreSQLParserRULE_alter_generic_options)
	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(3609)
		p.Match(PostgreSQLParserOPTIONS)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(3610)
		p.Match(PostgreSQLParserOPEN_PAREN)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(3611)
		p.Alter_generic_option_list()
	}
	{
		p.SetState(3612)
		p.Match(PostgreSQLParserCLOSE_PAREN)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IAlter_generic_option_listContext is an interface to support dynamic dispatch.
type IAlter_generic_option_listContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	AllAlter_generic_option_elem() []IAlter_generic_option_elemContext
	Alter_generic_option_elem(i int) IAlter_generic_option_elemContext
	AllCOMMA() []antlr.TerminalNode
	COMMA(i int) antlr.TerminalNode

	// IsAlter_generic_option_listContext differentiates from other interfaces.
	IsAlter_generic_option_listContext()
}

type Alter_generic_option_listContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyAlter_generic_option_listContext() *Alter_generic_option_listContext {
	var p = new(Alter_generic_option_listContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_alter_generic_option_list
	return p
}

func InitEmptyAlter_generic_option_listContext(p *Alter_generic_option_listContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_alter_generic_option_list
}

func (*Alter_generic_option_listContext) IsAlter_generic_option_listContext() {}

func NewAlter_generic_option_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_generic_option_listContext {
	var p = new(Alter_generic_option_listContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_alter_generic_option_list

	return p
}

func (s *Alter_generic_option_listContext) GetParser() antlr.Parser { return s.parser }

func (s *Alter_generic_option_listContext) AllAlter_generic_option_elem() []IAlter_generic_option_elemContext {
	children := s.GetChildren()
	len := 0
	for _, ctx := range children {
		if _, ok := ctx.(IAlter_generic_option_elemContext); ok {
			len++
		}
	}

	tst := make([]IAlter_generic_option_elemContext, len)
	i := 0
	for _, ctx := range children {
		if t, ok := ctx.(IAlter_generic_option_elemContext); ok {
			tst[i] = t.(IAlter_generic_option_elemContext)
			i++
		}
	}

	return tst
}

func (s *Alter_generic_option_listContext) Alter_generic_option_elem(i int) IAlter_generic_option_elemContext {
	var t antlr.RuleContext
	j := 0
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IAlter_generic_option_elemContext); ok {
			if j == i {
				t = ctx.(antlr.RuleContext)
				break
			}
			j++
		}
	}

	if t == nil {
		return nil
	}

	return t.(IAlter_generic_option_elemContext)
}

func (s *Alter_generic_option_listContext) AllCOMMA() []antlr.TerminalNode {
	return s.GetTokens(PostgreSQLParserCOMMA)
}

func (s *Alter_generic_option_listContext) COMMA(i int) antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCOMMA, i)
}

func (s *Alter_generic_option_listContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Alter_generic_option_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Alter_generic_option_listContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterAlter_generic_option_list(s)
	}
}

func (s *Alter_generic_option_listContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitAlter_generic_option_list(s)
	}
}

func (s *Alter_generic_option_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitAlter_generic_option_list(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Alter_generic_option_list() (localctx IAlter_generic_option_listContext) {
	localctx = NewAlter_generic_option_listContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 346, PostgreSQLParserRULE_alter_generic_option_list)
	var _la int

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(3614)
		p.Alter_generic_option_elem()
	}
	p.SetState(3619)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}
	_la = p.GetTokenStream().LA(1)

	for _la == PostgreSQLParserCOMMA {
		{
			p.SetState(3615)
			p.Match(PostgreSQLParserCOMMA)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(3616)
			p.Alter_generic_option_elem()
		}

		p.SetState(3621)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}
		_la = p.GetTokenStream().LA(1)
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IAlter_generic_option_elemContext is an interface to support dynamic dispatch.
type IAlter_generic_option_elemContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Generic_option_elem() IGeneric_option_elemContext
	SET() antlr.TerminalNode
	ADD_P() antlr.TerminalNode
	DROP() antlr.TerminalNode
	Generic_option_name() IGeneric_option_nameContext

	// IsAlter_generic_option_elemContext differentiates from other interfaces.
	IsAlter_generic_option_elemContext()
}

type Alter_generic_option_elemContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyAlter_generic_option_elemContext() *Alter_generic_option_elemContext {
	var p = new(Alter_generic_option_elemContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_alter_generic_option_elem
	return p
}

func InitEmptyAlter_generic_option_elemContext(p *Alter_generic_option_elemContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_alter_generic_option_elem
}

func (*Alter_generic_option_elemContext) IsAlter_generic_option_elemContext() {}

func NewAlter_generic_option_elemContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_generic_option_elemContext {
	var p = new(Alter_generic_option_elemContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_alter_generic_option_elem

	return p
}

func (s *Alter_generic_option_elemContext) GetParser() antlr.Parser { return s.parser }

func (s *Alter_generic_option_elemContext) Generic_option_elem() IGeneric_option_elemContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IGeneric_option_elemContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IGeneric_option_elemContext)
}

func (s *Alter_generic_option_elemContext) SET() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserSET, 0)
}

func (s *Alter_generic_option_elemContext) ADD_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserADD_P, 0)
}

func (s *Alter_generic_option_elemContext) DROP() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserDROP, 0)
}

func (s *Alter_generic_option_elemContext) Generic_option_name() IGeneric_option_nameContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IGeneric_option_nameContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IGeneric_option_nameContext)
}

func (s *Alter_generic_option_elemContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Alter_generic_option_elemContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Alter_generic_option_elemContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterAlter_generic_option_elem(s)
	}
}

func (s *Alter_generic_option_elemContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitAlter_generic_option_elem(s)
	}
}

func (s *Alter_generic_option_elemContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitAlter_generic_option_elem(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Alter_generic_option_elem() (localctx IAlter_generic_option_elemContext) {
	localctx = NewAlter_generic_option_elemContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 348, PostgreSQLParserRULE_alter_generic_option_elem)
	p.SetState(3629)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 160, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(3622)
			p.Generic_option_elem()
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(3623)
			p.Match(PostgreSQLParserSET)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(3624)
			p.Generic_option_elem()
		}

	case 3:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(3625)
			p.Match(PostgreSQLParserADD_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(3626)
			p.Generic_option_elem()
		}

	case 4:
		p.EnterOuterAlt(localctx, 4)
		{
			p.SetState(3627)
			p.Match(PostgreSQLParserDROP)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(3628)
			p.Generic_option_name()
		}

	case antlr.ATNInvalidAltNumber:
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IGeneric_option_elemContext is an interface to support dynamic dispatch.
type IGeneric_option_elemContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Generic_option_name() IGeneric_option_nameContext
	Generic_option_arg() IGeneric_option_argContext

	// IsGeneric_option_elemContext differentiates from other interfaces.
	IsGeneric_option_elemContext()
}

type Generic_option_elemContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyGeneric_option_elemContext() *Generic_option_elemContext {
	var p = new(Generic_option_elemContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_generic_option_elem
	return p
}

func InitEmptyGeneric_option_elemContext(p *Generic_option_elemContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_generic_option_elem
}

func (*Generic_option_elemContext) IsGeneric_option_elemContext() {}

func NewGeneric_option_elemContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Generic_option_elemContext {
	var p = new(Generic_option_elemContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_generic_option_elem

	return p
}

func (s *Generic_option_elemContext) GetParser() antlr.Parser { return s.parser }

func (s *Generic_option_elemContext) Generic_option_name() IGeneric_option_nameContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IGeneric_option_nameContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IGeneric_option_nameContext)
}

func (s *Generic_option_elemContext) Generic_option_arg() IGeneric_option_argContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IGeneric_option_argContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IGeneric_option_argContext)
}

func (s *Generic_option_elemContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Generic_option_elemContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Generic_option_elemContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterGeneric_option_elem(s)
	}
}

func (s *Generic_option_elemContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitGeneric_option_elem(s)
	}
}

func (s *Generic_option_elemContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitGeneric_option_elem(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Generic_option_elem() (localctx IGeneric_option_elemContext) {
	localctx = NewGeneric_option_elemContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 350, PostgreSQLParserRULE_generic_option_elem)
	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(3631)
		p.Generic_option_name()
	}
	{
		p.SetState(3632)
		p.Generic_option_arg()
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IGeneric_option_nameContext is an interface to support dynamic dispatch.
type IGeneric_option_nameContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Collabel() ICollabelContext

	// IsGeneric_option_nameContext differentiates from other interfaces.
	IsGeneric_option_nameContext()
}

type Generic_option_nameContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyGeneric_option_nameContext() *Generic_option_nameContext {
	var p = new(Generic_option_nameContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_generic_option_name
	return p
}

func InitEmptyGeneric_option_nameContext(p *Generic_option_nameContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_generic_option_name
}

func (*Generic_option_nameContext) IsGeneric_option_nameContext() {}

func NewGeneric_option_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Generic_option_nameContext {
	var p = new(Generic_option_nameContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_generic_option_name

	return p
}

func (s *Generic_option_nameContext) GetParser() antlr.Parser { return s.parser }

func (s *Generic_option_nameContext) Collabel() ICollabelContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ICollabelContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ICollabelContext)
}

func (s *Generic_option_nameContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Generic_option_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Generic_option_nameContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterGeneric_option_name(s)
	}
}

func (s *Generic_option_nameContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitGeneric_option_name(s)
	}
}

func (s *Generic_option_nameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitGeneric_option_name(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Generic_option_name() (localctx IGeneric_option_nameContext) {
	localctx = NewGeneric_option_nameContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 352, PostgreSQLParserRULE_generic_option_name)
	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(3634)
		p.Collabel()
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IGeneric_option_argContext is an interface to support dynamic dispatch.
type IGeneric_option_argContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Sconst() ISconstContext

	// IsGeneric_option_argContext differentiates from other interfaces.
	IsGeneric_option_argContext()
}

type Generic_option_argContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyGeneric_option_argContext() *Generic_option_argContext {
	var p = new(Generic_option_argContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_generic_option_arg
	return p
}

func InitEmptyGeneric_option_argContext(p *Generic_option_argContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_generic_option_arg
}

func (*Generic_option_argContext) IsGeneric_option_argContext() {}

func NewGeneric_option_argContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Generic_option_argContext {
	var p = new(Generic_option_argContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_generic_option_arg

	return p
}

func (s *Generic_option_argContext) GetParser() antlr.Parser { return s.parser }

func (s *Generic_option_argContext) Sconst() ISconstContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ISconstContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ISconstContext)
}

func (s *Generic_option_argContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Generic_option_argContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Generic_option_argContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterGeneric_option_arg(s)
	}
}

func (s *Generic_option_argContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitGeneric_option_arg(s)
	}
}

func (s *Generic_option_argContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitGeneric_option_arg(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Generic_option_arg() (localctx IGeneric_option_argContext) {
	localctx = NewGeneric_option_argContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 354, PostgreSQLParserRULE_generic_option_arg)
	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(3636)
		p.Sconst()
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// ICreateforeignserverstmtContext is an interface to support dynamic dispatch.
type ICreateforeignserverstmtContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	CREATE() antlr.TerminalNode
	SERVER() antlr.TerminalNode
	AllName() []INameContext
	Name(i int) INameContext
	Opt_type() IOpt_typeContext
	Opt_foreign_server_version() IOpt_foreign_server_versionContext
	FOREIGN() antlr.TerminalNode
	DATA_P() antlr.TerminalNode
	WRAPPER() antlr.TerminalNode
	Create_generic_options() ICreate_generic_optionsContext
	IF_P() antlr.TerminalNode
	NOT() antlr.TerminalNode
	EXISTS() antlr.TerminalNode

	// IsCreateforeignserverstmtContext differentiates from other interfaces.
	IsCreateforeignserverstmtContext()
}

type CreateforeignserverstmtContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyCreateforeignserverstmtContext() *CreateforeignserverstmtContext {
	var p = new(CreateforeignserverstmtContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_createforeignserverstmt
	return p
}

func InitEmptyCreateforeignserverstmtContext(p *CreateforeignserverstmtContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_createforeignserverstmt
}

func (*CreateforeignserverstmtContext) IsCreateforeignserverstmtContext() {}

func NewCreateforeignserverstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CreateforeignserverstmtContext {
	var p = new(CreateforeignserverstmtContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_createforeignserverstmt

	return p
}

func (s *CreateforeignserverstmtContext) GetParser() antlr.Parser { return s.parser }

func (s *CreateforeignserverstmtContext) CREATE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCREATE, 0)
}

func (s *CreateforeignserverstmtContext) SERVER() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserSERVER, 0)
}

func (s *CreateforeignserverstmtContext) AllName() []INameContext {
	children := s.GetChildren()
	len := 0
	for _, ctx := range children {
		if _, ok := ctx.(INameContext); ok {
			len++
		}
	}

	tst := make([]INameContext, len)
	i := 0
	for _, ctx := range children {
		if t, ok := ctx.(INameContext); ok {
			tst[i] = t.(INameContext)
			i++
		}
	}

	return tst
}

func (s *CreateforeignserverstmtContext) Name(i int) INameContext {
	var t antlr.RuleContext
	j := 0
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(INameContext); ok {
			if j == i {
				t = ctx.(antlr.RuleContext)
				break
			}
			j++
		}
	}

	if t == nil {
		return nil
	}

	return t.(INameContext)
}

func (s *CreateforeignserverstmtContext) Opt_type() IOpt_typeContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOpt_typeContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOpt_typeContext)
}

func (s *CreateforeignserverstmtContext) Opt_foreign_server_version() IOpt_foreign_server_versionContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOpt_foreign_server_versionContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOpt_foreign_server_versionContext)
}

func (s *CreateforeignserverstmtContext) FOREIGN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserFOREIGN, 0)
}

func (s *CreateforeignserverstmtContext) DATA_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserDATA_P, 0)
}

func (s *CreateforeignserverstmtContext) WRAPPER() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserWRAPPER, 0)
}

func (s *CreateforeignserverstmtContext) Create_generic_options() ICreate_generic_optionsContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ICreate_generic_optionsContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ICreate_generic_optionsContext)
}

func (s *CreateforeignserverstmtContext) IF_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserIF_P, 0)
}

func (s *CreateforeignserverstmtContext) NOT() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserNOT, 0)
}

func (s *CreateforeignserverstmtContext) EXISTS() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserEXISTS, 0)
}

func (s *CreateforeignserverstmtContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *CreateforeignserverstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *CreateforeignserverstmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterCreateforeignserverstmt(s)
	}
}

func (s *CreateforeignserverstmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitCreateforeignserverstmt(s)
	}
}

func (s *CreateforeignserverstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitCreateforeignserverstmt(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Createforeignserverstmt() (localctx ICreateforeignserverstmtContext) {
	localctx = NewCreateforeignserverstmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 356, PostgreSQLParserRULE_createforeignserverstmt)
	p.SetState(3663)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 161, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(3638)
			p.Match(PostgreSQLParserCREATE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(3639)
			p.Match(PostgreSQLParserSERVER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(3640)
			p.Name()
		}
		{
			p.SetState(3641)
			p.Opt_type()
		}
		{
			p.SetState(3642)
			p.Opt_foreign_server_version()
		}
		{
			p.SetState(3643)
			p.Match(PostgreSQLParserFOREIGN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(3644)
			p.Match(PostgreSQLParserDATA_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(3645)
			p.Match(PostgreSQLParserWRAPPER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(3646)
			p.Name()
		}
		{
			p.SetState(3647)
			p.Create_generic_options()
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(3649)
			p.Match(PostgreSQLParserCREATE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(3650)
			p.Match(PostgreSQLParserSERVER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(3651)
			p.Match(PostgreSQLParserIF_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(3652)
			p.Match(PostgreSQLParserNOT)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(3653)
			p.Match(PostgreSQLParserEXISTS)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(3654)
			p.Name()
		}
		{
			p.SetState(3655)
			p.Opt_type()
		}
		{
			p.SetState(3656)
			p.Opt_foreign_server_version()
		}
		{
			p.SetState(3657)
			p.Match(PostgreSQLParserFOREIGN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(3658)
			p.Match(PostgreSQLParserDATA_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(3659)
			p.Match(PostgreSQLParserWRAPPER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(3660)
			p.Name()
		}
		{
			p.SetState(3661)
			p.Create_generic_options()
		}

	case antlr.ATNInvalidAltNumber:
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IOpt_typeContext is an interface to support dynamic dispatch.
type IOpt_typeContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	TYPE_P() antlr.TerminalNode
	Sconst() ISconstContext

	// IsOpt_typeContext differentiates from other interfaces.
	IsOpt_typeContext()
}

type Opt_typeContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyOpt_typeContext() *Opt_typeContext {
	var p = new(Opt_typeContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opt_type
	return p
}

func InitEmptyOpt_typeContext(p *Opt_typeContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opt_type
}

func (*Opt_typeContext) IsOpt_typeContext() {}

func NewOpt_typeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_typeContext {
	var p = new(Opt_typeContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_opt_type

	return p
}

func (s *Opt_typeContext) GetParser() antlr.Parser { return s.parser }

func (s *Opt_typeContext) TYPE_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserTYPE_P, 0)
}

func (s *Opt_typeContext) Sconst() ISconstContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ISconstContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ISconstContext)
}

func (s *Opt_typeContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Opt_typeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Opt_typeContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterOpt_type(s)
	}
}

func (s *Opt_typeContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitOpt_type(s)
	}
}

func (s *Opt_typeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitOpt_type(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Opt_type() (localctx IOpt_typeContext) {
	localctx = NewOpt_typeContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 358, PostgreSQLParserRULE_opt_type)
	p.SetState(3668)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetTokenStream().LA(1) {
	case PostgreSQLParserTYPE_P:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(3665)
			p.Match(PostgreSQLParserTYPE_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(3666)
			p.Sconst()
		}

	case PostgreSQLParserFOREIGN, PostgreSQLParserVERSION_P:
		p.EnterOuterAlt(localctx, 2)

	default:
		p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IForeign_server_versionContext is an interface to support dynamic dispatch.
type IForeign_server_versionContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	VERSION_P() antlr.TerminalNode
	Sconst() ISconstContext
	NULL_P() antlr.TerminalNode

	// IsForeign_server_versionContext differentiates from other interfaces.
	IsForeign_server_versionContext()
}

type Foreign_server_versionContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyForeign_server_versionContext() *Foreign_server_versionContext {
	var p = new(Foreign_server_versionContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_foreign_server_version
	return p
}

func InitEmptyForeign_server_versionContext(p *Foreign_server_versionContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_foreign_server_version
}

func (*Foreign_server_versionContext) IsForeign_server_versionContext() {}

func NewForeign_server_versionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Foreign_server_versionContext {
	var p = new(Foreign_server_versionContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_foreign_server_version

	return p
}

func (s *Foreign_server_versionContext) GetParser() antlr.Parser { return s.parser }

func (s *Foreign_server_versionContext) VERSION_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserVERSION_P, 0)
}

func (s *Foreign_server_versionContext) Sconst() ISconstContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ISconstContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ISconstContext)
}

func (s *Foreign_server_versionContext) NULL_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserNULL_P, 0)
}

func (s *Foreign_server_versionContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Foreign_server_versionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Foreign_server_versionContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterForeign_server_version(s)
	}
}

func (s *Foreign_server_versionContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitForeign_server_version(s)
	}
}

func (s *Foreign_server_versionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitForeign_server_version(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Foreign_server_version() (localctx IForeign_server_versionContext) {
	localctx = NewForeign_server_versionContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 360, PostgreSQLParserRULE_foreign_server_version)
	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(3670)
		p.Match(PostgreSQLParserVERSION_P)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	p.SetState(3673)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetTokenStream().LA(1) {
	case PostgreSQLParserStringConstant, PostgreSQLParserUnicodeEscapeStringConstant, PostgreSQLParserBeginDollarStringConstant, PostgreSQLParserEscapeStringConstant:
		{
			p.SetState(3671)
			p.Sconst()
		}

	case PostgreSQLParserNULL_P:
		{
			p.SetState(3672)
			p.Match(PostgreSQLParserNULL_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	default:
		p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IOpt_foreign_server_versionContext is an interface to support dynamic dispatch.
type IOpt_foreign_server_versionContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Foreign_server_version() IForeign_server_versionContext

	// IsOpt_foreign_server_versionContext differentiates from other interfaces.
	IsOpt_foreign_server_versionContext()
}

type Opt_foreign_server_versionContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyOpt_foreign_server_versionContext() *Opt_foreign_server_versionContext {
	var p = new(Opt_foreign_server_versionContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opt_foreign_server_version
	return p
}

func InitEmptyOpt_foreign_server_versionContext(p *Opt_foreign_server_versionContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opt_foreign_server_version
}

func (*Opt_foreign_server_versionContext) IsOpt_foreign_server_versionContext() {}

func NewOpt_foreign_server_versionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_foreign_server_versionContext {
	var p = new(Opt_foreign_server_versionContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_opt_foreign_server_version

	return p
}

func (s *Opt_foreign_server_versionContext) GetParser() antlr.Parser { return s.parser }

func (s *Opt_foreign_server_versionContext) Foreign_server_version() IForeign_server_versionContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IForeign_server_versionContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IForeign_server_versionContext)
}

func (s *Opt_foreign_server_versionContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Opt_foreign_server_versionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Opt_foreign_server_versionContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterOpt_foreign_server_version(s)
	}
}

func (s *Opt_foreign_server_versionContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitOpt_foreign_server_version(s)
	}
}

func (s *Opt_foreign_server_versionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitOpt_foreign_server_version(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Opt_foreign_server_version() (localctx IOpt_foreign_server_versionContext) {
	localctx = NewOpt_foreign_server_versionContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 362, PostgreSQLParserRULE_opt_foreign_server_version)
	p.SetState(3677)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetTokenStream().LA(1) {
	case PostgreSQLParserVERSION_P:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(3675)
			p.Foreign_server_version()
		}

	case PostgreSQLParserFOREIGN:
		p.EnterOuterAlt(localctx, 2)

	default:
		p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IAlterforeignserverstmtContext is an interface to support dynamic dispatch.
type IAlterforeignserverstmtContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	ALTER() antlr.TerminalNode
	SERVER() antlr.TerminalNode
	Name() INameContext
	Alter_generic_options() IAlter_generic_optionsContext
	Foreign_server_version() IForeign_server_versionContext

	// IsAlterforeignserverstmtContext differentiates from other interfaces.
	IsAlterforeignserverstmtContext()
}

type AlterforeignserverstmtContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyAlterforeignserverstmtContext() *AlterforeignserverstmtContext {
	var p = new(AlterforeignserverstmtContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_alterforeignserverstmt
	return p
}

func InitEmptyAlterforeignserverstmtContext(p *AlterforeignserverstmtContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_alterforeignserverstmt
}

func (*AlterforeignserverstmtContext) IsAlterforeignserverstmtContext() {}

func NewAlterforeignserverstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AlterforeignserverstmtContext {
	var p = new(AlterforeignserverstmtContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_alterforeignserverstmt

	return p
}

func (s *AlterforeignserverstmtContext) GetParser() antlr.Parser { return s.parser }

func (s *AlterforeignserverstmtContext) ALTER() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserALTER, 0)
}

func (s *AlterforeignserverstmtContext) SERVER() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserSERVER, 0)
}

func (s *AlterforeignserverstmtContext) Name() INameContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(INameContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(INameContext)
}

func (s *AlterforeignserverstmtContext) Alter_generic_options() IAlter_generic_optionsContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IAlter_generic_optionsContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IAlter_generic_optionsContext)
}

func (s *AlterforeignserverstmtContext) Foreign_server_version() IForeign_server_versionContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IForeign_server_versionContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IForeign_server_versionContext)
}

func (s *AlterforeignserverstmtContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *AlterforeignserverstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *AlterforeignserverstmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterAlterforeignserverstmt(s)
	}
}

func (s *AlterforeignserverstmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitAlterforeignserverstmt(s)
	}
}

func (s *AlterforeignserverstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitAlterforeignserverstmt(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Alterforeignserverstmt() (localctx IAlterforeignserverstmtContext) {
	localctx = NewAlterforeignserverstmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 364, PostgreSQLParserRULE_alterforeignserverstmt)
	var _la int

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(3679)
		p.Match(PostgreSQLParserALTER)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(3680)
		p.Match(PostgreSQLParserSERVER)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(3681)
		p.Name()
	}
	p.SetState(3687)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetTokenStream().LA(1) {
	case PostgreSQLParserOPTIONS:
		{
			p.SetState(3682)
			p.Alter_generic_options()
		}

	case PostgreSQLParserVERSION_P:
		{
			p.SetState(3683)
			p.Foreign_server_version()
		}
		p.SetState(3685)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}
		_la = p.GetTokenStream().LA(1)

		if _la == PostgreSQLParserOPTIONS {
			{
				p.SetState(3684)
				p.Alter_generic_options()
			}

		}

	default:
		p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// ICreateforeigntablestmtContext is an interface to support dynamic dispatch.
type ICreateforeigntablestmtContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	CREATE() antlr.TerminalNode
	FOREIGN() antlr.TerminalNode
	TABLE() antlr.TerminalNode
	AllQualified_name() []IQualified_nameContext
	Qualified_name(i int) IQualified_nameContext
	OPEN_PAREN() antlr.TerminalNode
	Opttableelementlist() IOpttableelementlistContext
	CLOSE_PAREN() antlr.TerminalNode
	Optinherit() IOptinheritContext
	SERVER() antlr.TerminalNode
	Name() INameContext
	Create_generic_options() ICreate_generic_optionsContext
	IF_P() antlr.TerminalNode
	NOT() antlr.TerminalNode
	EXISTS() antlr.TerminalNode
	PARTITION() antlr.TerminalNode
	OF() antlr.TerminalNode
	Opttypedtableelementlist() IOpttypedtableelementlistContext
	Partitionboundspec() IPartitionboundspecContext

	// IsCreateforeigntablestmtContext differentiates from other interfaces.
	IsCreateforeigntablestmtContext()
}

type CreateforeigntablestmtContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyCreateforeigntablestmtContext() *CreateforeigntablestmtContext {
	var p = new(CreateforeigntablestmtContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_createforeigntablestmt
	return p
}

func InitEmptyCreateforeigntablestmtContext(p *CreateforeigntablestmtContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_createforeigntablestmt
}

func (*CreateforeigntablestmtContext) IsCreateforeigntablestmtContext() {}

func NewCreateforeigntablestmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CreateforeigntablestmtContext {
	var p = new(CreateforeigntablestmtContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_createforeigntablestmt

	return p
}

func (s *CreateforeigntablestmtContext) GetParser() antlr.Parser { return s.parser }

func (s *CreateforeigntablestmtContext) CREATE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCREATE, 0)
}

func (s *CreateforeigntablestmtContext) FOREIGN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserFOREIGN, 0)
}

func (s *CreateforeigntablestmtContext) TABLE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserTABLE, 0)
}

func (s *CreateforeigntablestmtContext) AllQualified_name() []IQualified_nameContext {
	children := s.GetChildren()
	len := 0
	for _, ctx := range children {
		if _, ok := ctx.(IQualified_nameContext); ok {
			len++
		}
	}

	tst := make([]IQualified_nameContext, len)
	i := 0
	for _, ctx := range children {
		if t, ok := ctx.(IQualified_nameContext); ok {
			tst[i] = t.(IQualified_nameContext)
			i++
		}
	}

	return tst
}

func (s *CreateforeigntablestmtContext) Qualified_name(i int) IQualified_nameContext {
	var t antlr.RuleContext
	j := 0
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IQualified_nameContext); ok {
			if j == i {
				t = ctx.(antlr.RuleContext)
				break
			}
			j++
		}
	}

	if t == nil {
		return nil
	}

	return t.(IQualified_nameContext)
}

func (s *CreateforeigntablestmtContext) OPEN_PAREN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserOPEN_PAREN, 0)
}

func (s *CreateforeigntablestmtContext) Opttableelementlist() IOpttableelementlistContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOpttableelementlistContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOpttableelementlistContext)
}

func (s *CreateforeigntablestmtContext) CLOSE_PAREN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCLOSE_PAREN, 0)
}

func (s *CreateforeigntablestmtContext) Optinherit() IOptinheritContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOptinheritContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOptinheritContext)
}

func (s *CreateforeigntablestmtContext) SERVER() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserSERVER, 0)
}

func (s *CreateforeigntablestmtContext) Name() INameContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(INameContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(INameContext)
}

func (s *CreateforeigntablestmtContext) Create_generic_options() ICreate_generic_optionsContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ICreate_generic_optionsContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ICreate_generic_optionsContext)
}

func (s *CreateforeigntablestmtContext) IF_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserIF_P, 0)
}

func (s *CreateforeigntablestmtContext) NOT() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserNOT, 0)
}

func (s *CreateforeigntablestmtContext) EXISTS() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserEXISTS, 0)
}

func (s *CreateforeigntablestmtContext) PARTITION() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserPARTITION, 0)
}

func (s *CreateforeigntablestmtContext) OF() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserOF, 0)
}

func (s *CreateforeigntablestmtContext) Opttypedtableelementlist() IOpttypedtableelementlistContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOpttypedtableelementlistContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOpttypedtableelementlistContext)
}

func (s *CreateforeigntablestmtContext) Partitionboundspec() IPartitionboundspecContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IPartitionboundspecContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IPartitionboundspecContext)
}

func (s *CreateforeigntablestmtContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *CreateforeigntablestmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *CreateforeigntablestmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterCreateforeigntablestmt(s)
	}
}

func (s *CreateforeigntablestmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitCreateforeigntablestmt(s)
	}
}

func (s *CreateforeigntablestmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitCreateforeigntablestmt(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Createforeigntablestmt() (localctx ICreateforeigntablestmtContext) {
	localctx = NewCreateforeigntablestmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 366, PostgreSQLParserRULE_createforeigntablestmt)
	p.SetState(3745)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 167, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(3689)
			p.Match(PostgreSQLParserCREATE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(3690)
			p.Match(PostgreSQLParserFOREIGN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(3691)
			p.Match(PostgreSQLParserTABLE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(3692)
			p.Qualified_name()
		}
		{
			p.SetState(3693)
			p.Match(PostgreSQLParserOPEN_PAREN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(3694)
			p.Opttableelementlist()
		}
		{
			p.SetState(3695)
			p.Match(PostgreSQLParserCLOSE_PAREN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(3696)
			p.Optinherit()
		}
		{
			p.SetState(3697)
			p.Match(PostgreSQLParserSERVER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(3698)
			p.Name()
		}
		{
			p.SetState(3699)
			p.Create_generic_options()
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(3701)
			p.Match(PostgreSQLParserCREATE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(3702)
			p.Match(PostgreSQLParserFOREIGN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(3703)
			p.Match(PostgreSQLParserTABLE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(3704)
			p.Match(PostgreSQLParserIF_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(3705)
			p.Match(PostgreSQLParserNOT)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(3706)
			p.Match(PostgreSQLParserEXISTS)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(3707)
			p.Qualified_name()
		}
		{
			p.SetState(3708)
			p.Match(PostgreSQLParserOPEN_PAREN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(3709)
			p.Opttableelementlist()
		}
		{
			p.SetState(3710)
			p.Match(PostgreSQLParserCLOSE_PAREN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(3711)
			p.Optinherit()
		}
		{
			p.SetState(3712)
			p.Match(PostgreSQLParserSERVER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(3713)
			p.Name()
		}
		{
			p.SetState(3714)
			p.Create_generic_options()
		}

	case 3:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(3716)
			p.Match(PostgreSQLParserCREATE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(3717)
			p.Match(PostgreSQLParserFOREIGN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(3718)
			p.Match(PostgreSQLParserTABLE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(3719)
			p.Qualified_name()
		}
		{
			p.SetState(3720)
			p.Match(PostgreSQLParserPARTITION)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(3721)
			p.Match(PostgreSQLParserOF)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(3722)
			p.Qualified_name()
		}
		{
			p.SetState(3723)
			p.Opttypedtableelementlist()
		}
		{
			p.SetState(3724)
			p.Partitionboundspec()
		}
		{
			p.SetState(3725)
			p.Match(PostgreSQLParserSERVER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(3726)
			p.Name()
		}
		{
			p.SetState(3727)
			p.Create_generic_options()
		}

	case 4:
		p.EnterOuterAlt(localctx, 4)
		{
			p.SetState(3729)
			p.Match(PostgreSQLParserCREATE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(3730)
			p.Match(PostgreSQLParserFOREIGN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(3731)
			p.Match(PostgreSQLParserTABLE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(3732)
			p.Match(PostgreSQLParserIF_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(3733)
			p.Match(PostgreSQLParserNOT)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(3734)
			p.Match(PostgreSQLParserEXISTS)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(3735)
			p.Qualified_name()
		}
		{
			p.SetState(3736)
			p.Match(PostgreSQLParserPARTITION)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(3737)
			p.Match(PostgreSQLParserOF)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(3738)
			p.Qualified_name()
		}
		{
			p.SetState(3739)
			p.Opttypedtableelementlist()
		}
		{
			p.SetState(3740)
			p.Partitionboundspec()
		}
		{
			p.SetState(3741)
			p.Match(PostgreSQLParserSERVER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(3742)
			p.Name()
		}
		{
			p.SetState(3743)
			p.Create_generic_options()
		}

	case antlr.ATNInvalidAltNumber:
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IImportforeignschemastmtContext is an interface to support dynamic dispatch.
type IImportforeignschemastmtContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	IMPORT_P() antlr.TerminalNode
	FOREIGN() antlr.TerminalNode
	SCHEMA() antlr.TerminalNode
	AllName() []INameContext
	Name(i int) INameContext
	Import_qualification() IImport_qualificationContext
	FROM() antlr.TerminalNode
	SERVER() antlr.TerminalNode
	INTO() antlr.TerminalNode
	Create_generic_options() ICreate_generic_optionsContext

	// IsImportforeignschemastmtContext differentiates from other interfaces.
	IsImportforeignschemastmtContext()
}

type ImportforeignschemastmtContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyImportforeignschemastmtContext() *ImportforeignschemastmtContext {
	var p = new(ImportforeignschemastmtContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_importforeignschemastmt
	return p
}

func InitEmptyImportforeignschemastmtContext(p *ImportforeignschemastmtContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_importforeignschemastmt
}

func (*ImportforeignschemastmtContext) IsImportforeignschemastmtContext() {}

func NewImportforeignschemastmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ImportforeignschemastmtContext {
	var p = new(ImportforeignschemastmtContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_importforeignschemastmt

	return p
}

func (s *ImportforeignschemastmtContext) GetParser() antlr.Parser { return s.parser }

func (s *ImportforeignschemastmtContext) IMPORT_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserIMPORT_P, 0)
}

func (s *ImportforeignschemastmtContext) FOREIGN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserFOREIGN, 0)
}

func (s *ImportforeignschemastmtContext) SCHEMA() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserSCHEMA, 0)
}

func (s *ImportforeignschemastmtContext) AllName() []INameContext {
	children := s.GetChildren()
	len := 0
	for _, ctx := range children {
		if _, ok := ctx.(INameContext); ok {
			len++
		}
	}

	tst := make([]INameContext, len)
	i := 0
	for _, ctx := range children {
		if t, ok := ctx.(INameContext); ok {
			tst[i] = t.(INameContext)
			i++
		}
	}

	return tst
}

func (s *ImportforeignschemastmtContext) Name(i int) INameContext {
	var t antlr.RuleContext
	j := 0
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(INameContext); ok {
			if j == i {
				t = ctx.(antlr.RuleContext)
				break
			}
			j++
		}
	}

	if t == nil {
		return nil
	}

	return t.(INameContext)
}

func (s *ImportforeignschemastmtContext) Import_qualification() IImport_qualificationContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IImport_qualificationContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IImport_qualificationContext)
}

func (s *ImportforeignschemastmtContext) FROM() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserFROM, 0)
}

func (s *ImportforeignschemastmtContext) SERVER() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserSERVER, 0)
}

func (s *ImportforeignschemastmtContext) INTO() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserINTO, 0)
}

func (s *ImportforeignschemastmtContext) Create_generic_options() ICreate_generic_optionsContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ICreate_generic_optionsContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ICreate_generic_optionsContext)
}

func (s *ImportforeignschemastmtContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *ImportforeignschemastmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *ImportforeignschemastmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterImportforeignschemastmt(s)
	}
}

func (s *ImportforeignschemastmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitImportforeignschemastmt(s)
	}
}

func (s *ImportforeignschemastmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitImportforeignschemastmt(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Importforeignschemastmt() (localctx IImportforeignschemastmtContext) {
	localctx = NewImportforeignschemastmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 368, PostgreSQLParserRULE_importforeignschemastmt)
	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(3747)
		p.Match(PostgreSQLParserIMPORT_P)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(3748)
		p.Match(PostgreSQLParserFOREIGN)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(3749)
		p.Match(PostgreSQLParserSCHEMA)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(3750)
		p.Name()
	}
	{
		p.SetState(3751)
		p.Import_qualification()
	}
	{
		p.SetState(3752)
		p.Match(PostgreSQLParserFROM)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(3753)
		p.Match(PostgreSQLParserSERVER)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(3754)
		p.Name()
	}
	{
		p.SetState(3755)
		p.Match(PostgreSQLParserINTO)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(3756)
		p.Name()
	}
	{
		p.SetState(3757)
		p.Create_generic_options()
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IImport_qualification_typeContext is an interface to support dynamic dispatch.
type IImport_qualification_typeContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	LIMIT() antlr.TerminalNode
	TO() antlr.TerminalNode
	EXCEPT() antlr.TerminalNode

	// IsImport_qualification_typeContext differentiates from other interfaces.
	IsImport_qualification_typeContext()
}

type Import_qualification_typeContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyImport_qualification_typeContext() *Import_qualification_typeContext {
	var p = new(Import_qualification_typeContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_import_qualification_type
	return p
}

func InitEmptyImport_qualification_typeContext(p *Import_qualification_typeContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_import_qualification_type
}

func (*Import_qualification_typeContext) IsImport_qualification_typeContext() {}

func NewImport_qualification_typeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Import_qualification_typeContext {
	var p = new(Import_qualification_typeContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_import_qualification_type

	return p
}

func (s *Import_qualification_typeContext) GetParser() antlr.Parser { return s.parser }

func (s *Import_qualification_typeContext) LIMIT() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserLIMIT, 0)
}

func (s *Import_qualification_typeContext) TO() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserTO, 0)
}

func (s *Import_qualification_typeContext) EXCEPT() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserEXCEPT, 0)
}

func (s *Import_qualification_typeContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Import_qualification_typeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Import_qualification_typeContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterImport_qualification_type(s)
	}
}

func (s *Import_qualification_typeContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitImport_qualification_type(s)
	}
}

func (s *Import_qualification_typeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitImport_qualification_type(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Import_qualification_type() (localctx IImport_qualification_typeContext) {
	localctx = NewImport_qualification_typeContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 370, PostgreSQLParserRULE_import_qualification_type)
	p.SetState(3762)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetTokenStream().LA(1) {
	case PostgreSQLParserLIMIT:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(3759)
			p.Match(PostgreSQLParserLIMIT)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(3760)
			p.Match(PostgreSQLParserTO)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case PostgreSQLParserEXCEPT:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(3761)
			p.Match(PostgreSQLParserEXCEPT)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	default:
		p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IImport_qualificationContext is an interface to support dynamic dispatch.
type IImport_qualificationContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Import_qualification_type() IImport_qualification_typeContext
	OPEN_PAREN() antlr.TerminalNode
	Relation_expr_list() IRelation_expr_listContext
	CLOSE_PAREN() antlr.TerminalNode

	// IsImport_qualificationContext differentiates from other interfaces.
	IsImport_qualificationContext()
}

type Import_qualificationContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyImport_qualificationContext() *Import_qualificationContext {
	var p = new(Import_qualificationContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_import_qualification
	return p
}

func InitEmptyImport_qualificationContext(p *Import_qualificationContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_import_qualification
}

func (*Import_qualificationContext) IsImport_qualificationContext() {}

func NewImport_qualificationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Import_qualificationContext {
	var p = new(Import_qualificationContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_import_qualification

	return p
}

func (s *Import_qualificationContext) GetParser() antlr.Parser { return s.parser }

func (s *Import_qualificationContext) Import_qualification_type() IImport_qualification_typeContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IImport_qualification_typeContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IImport_qualification_typeContext)
}

func (s *Import_qualificationContext) OPEN_PAREN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserOPEN_PAREN, 0)
}

func (s *Import_qualificationContext) Relation_expr_list() IRelation_expr_listContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IRelation_expr_listContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IRelation_expr_listContext)
}

func (s *Import_qualificationContext) CLOSE_PAREN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCLOSE_PAREN, 0)
}

func (s *Import_qualificationContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Import_qualificationContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Import_qualificationContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterImport_qualification(s)
	}
}

func (s *Import_qualificationContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitImport_qualification(s)
	}
}

func (s *Import_qualificationContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitImport_qualification(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Import_qualification() (localctx IImport_qualificationContext) {
	localctx = NewImport_qualificationContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 372, PostgreSQLParserRULE_import_qualification)
	p.SetState(3770)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetTokenStream().LA(1) {
	case PostgreSQLParserEXCEPT, PostgreSQLParserLIMIT:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(3764)
			p.Import_qualification_type()
		}
		{
			p.SetState(3765)
			p.Match(PostgreSQLParserOPEN_PAREN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(3766)
			p.Relation_expr_list()
		}
		{
			p.SetState(3767)
			p.Match(PostgreSQLParserCLOSE_PAREN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case PostgreSQLParserFROM:
		p.EnterOuterAlt(localctx, 2)

	default:
		p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// ICreateusermappingstmtContext is an interface to support dynamic dispatch.
type ICreateusermappingstmtContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	CREATE() antlr.TerminalNode
	USER() antlr.TerminalNode
	MAPPING() antlr.TerminalNode
	FOR() antlr.TerminalNode
	Auth_ident() IAuth_identContext
	SERVER() antlr.TerminalNode
	Name() INameContext
	Create_generic_options() ICreate_generic_optionsContext
	IF_P() antlr.TerminalNode
	NOT() antlr.TerminalNode
	EXISTS() antlr.TerminalNode

	// IsCreateusermappingstmtContext differentiates from other interfaces.
	IsCreateusermappingstmtContext()
}

type CreateusermappingstmtContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyCreateusermappingstmtContext() *CreateusermappingstmtContext {
	var p = new(CreateusermappingstmtContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_createusermappingstmt
	return p
}

func InitEmptyCreateusermappingstmtContext(p *CreateusermappingstmtContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_createusermappingstmt
}

func (*CreateusermappingstmtContext) IsCreateusermappingstmtContext() {}

func NewCreateusermappingstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CreateusermappingstmtContext {
	var p = new(CreateusermappingstmtContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_createusermappingstmt

	return p
}

func (s *CreateusermappingstmtContext) GetParser() antlr.Parser { return s.parser }

func (s *CreateusermappingstmtContext) CREATE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCREATE, 0)
}

func (s *CreateusermappingstmtContext) USER() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserUSER, 0)
}

func (s *CreateusermappingstmtContext) MAPPING() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserMAPPING, 0)
}

func (s *CreateusermappingstmtContext) FOR() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserFOR, 0)
}

func (s *CreateusermappingstmtContext) Auth_ident() IAuth_identContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IAuth_identContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IAuth_identContext)
}

func (s *CreateusermappingstmtContext) SERVER() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserSERVER, 0)
}

func (s *CreateusermappingstmtContext) Name() INameContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(INameContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(INameContext)
}

func (s *CreateusermappingstmtContext) Create_generic_options() ICreate_generic_optionsContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ICreate_generic_optionsContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ICreate_generic_optionsContext)
}

func (s *CreateusermappingstmtContext) IF_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserIF_P, 0)
}

func (s *CreateusermappingstmtContext) NOT() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserNOT, 0)
}

func (s *CreateusermappingstmtContext) EXISTS() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserEXISTS, 0)
}

func (s *CreateusermappingstmtContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *CreateusermappingstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *CreateusermappingstmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterCreateusermappingstmt(s)
	}
}

func (s *CreateusermappingstmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitCreateusermappingstmt(s)
	}
}

func (s *CreateusermappingstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitCreateusermappingstmt(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Createusermappingstmt() (localctx ICreateusermappingstmtContext) {
	localctx = NewCreateusermappingstmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 374, PostgreSQLParserRULE_createusermappingstmt)
	p.SetState(3793)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 170, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(3772)
			p.Match(PostgreSQLParserCREATE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(3773)
			p.Match(PostgreSQLParserUSER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(3774)
			p.Match(PostgreSQLParserMAPPING)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(3775)
			p.Match(PostgreSQLParserFOR)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(3776)
			p.Auth_ident()
		}
		{
			p.SetState(3777)
			p.Match(PostgreSQLParserSERVER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(3778)
			p.Name()
		}
		{
			p.SetState(3779)
			p.Create_generic_options()
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(3781)
			p.Match(PostgreSQLParserCREATE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(3782)
			p.Match(PostgreSQLParserUSER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(3783)
			p.Match(PostgreSQLParserMAPPING)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(3784)
			p.Match(PostgreSQLParserIF_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(3785)
			p.Match(PostgreSQLParserNOT)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(3786)
			p.Match(PostgreSQLParserEXISTS)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(3787)
			p.Match(PostgreSQLParserFOR)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(3788)
			p.Auth_ident()
		}
		{
			p.SetState(3789)
			p.Match(PostgreSQLParserSERVER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(3790)
			p.Name()
		}
		{
			p.SetState(3791)
			p.Create_generic_options()
		}

	case antlr.ATNInvalidAltNumber:
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IAuth_identContext is an interface to support dynamic dispatch.
type IAuth_identContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Rolespec() IRolespecContext
	USER() antlr.TerminalNode

	// IsAuth_identContext differentiates from other interfaces.
	IsAuth_identContext()
}

type Auth_identContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyAuth_identContext() *Auth_identContext {
	var p = new(Auth_identContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_auth_ident
	return p
}

func InitEmptyAuth_identContext(p *Auth_identContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_auth_ident
}

func (*Auth_identContext) IsAuth_identContext() {}

func NewAuth_identContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Auth_identContext {
	var p = new(Auth_identContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_auth_ident

	return p
}

func (s *Auth_identContext) GetParser() antlr.Parser { return s.parser }

func (s *Auth_identContext) Rolespec() IRolespecContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IRolespecContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IRolespecContext)
}

func (s *Auth_identContext) USER() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserUSER, 0)
}

func (s *Auth_identContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Auth_identContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Auth_identContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterAuth_ident(s)
	}
}

func (s *Auth_identContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitAuth_ident(s)
	}
}

func (s *Auth_identContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitAuth_ident(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Auth_ident() (localctx IAuth_identContext) {
	localctx = NewAuth_identContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 376, PostgreSQLParserRULE_auth_ident)
	p.SetState(3797)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetTokenStream().LA(1) {
	case PostgreSQLParserAND, PostgreSQLParserARRAY, PostgreSQLParserCOLLATE, PostgreSQLParserCOLUMN, PostgreSQLParserCONSTRAINT, PostgreSQLParserCURRENT_USER, PostgreSQLParserDEFAULT, PostgreSQLParserDO, PostgreSQLParserFETCH, PostgreSQLParserSESSION_USER, PostgreSQLParserTABLE, PostgreSQLParserAUTHORIZATION, PostgreSQLParserBINARY, PostgreSQLParserCOLLATION, PostgreSQLParserCONCURRENTLY, PostgreSQLParserCROSS, PostgreSQLParserCURRENT_SCHEMA, PostgreSQLParserFREEZE, PostgreSQLParserFULL, PostgreSQLParserILIKE, PostgreSQLParserINNER_P, PostgreSQLParserIS, PostgreSQLParserISNULL, PostgreSQLParserJOIN, PostgreSQLParserLIKE, PostgreSQLParserNATURAL, PostgreSQLParserNOTNULL, PostgreSQLParserOUTER_P, PostgreSQLParserOVER, PostgreSQLParserOVERLAPS, PostgreSQLParserSIMILAR, PostgreSQLParserVERBOSE, PostgreSQLParserABORT_P, PostgreSQLParserABSOLUTE_P, PostgreSQLParserACCESS, PostgreSQLParserACTION, PostgreSQLParserADD_P, PostgreSQLParserADMIN, PostgreSQLParserAFTER, PostgreSQLParserAGGREGATE, PostgreSQLParserALSO, PostgreSQLParserALTER, PostgreSQLParserALWAYS, PostgreSQLParserASSERTION, PostgreSQLParserASSIGNMENT, PostgreSQLParserAT, PostgreSQLParserATTRIBUTE, PostgreSQLParserBACKWARD, PostgreSQLParserBEFORE, PostgreSQLParserBEGIN_P, PostgreSQLParserBY, PostgreSQLParserCACHE, PostgreSQLParserCALLED, PostgreSQLParserCASCADE, PostgreSQLParserCASCADED, PostgreSQLParserCATALOG, PostgreSQLParserCHAIN, PostgreSQLParserCHARACTERISTICS, PostgreSQLParserCHECKPOINT, PostgreSQLParserCLASS, PostgreSQLParserCLOSE, PostgreSQLParserCLUSTER, PostgreSQLParserCOMMENT, PostgreSQLParserCOMMENTS, PostgreSQLParserCOMMIT, PostgreSQLParserCOMMITTED, PostgreSQLParserCONFIGURATION, PostgreSQLParserCONNECTION, PostgreSQLParserCONSTRAINTS, PostgreSQLParserCONTENT_P, PostgreSQLParserCONTINUE_P, PostgreSQLParserCONVERSION_P, PostgreSQLParserCOPY, PostgreSQLParserCOST, PostgreSQLParserCSV, PostgreSQLParserCURSOR, PostgreSQLParserCYCLE, PostgreSQLParserDATA_P, PostgreSQLParserDATABASE, PostgreSQLParserDAY_P, PostgreSQLParserDEALLOCATE, PostgreSQLParserDECLARE, PostgreSQLParserDEFAULTS, PostgreSQLParserDEFERRED, PostgreSQLParserDEFINER, PostgreSQLParserDELETE_P, PostgreSQLParserDELIMITER, PostgreSQLParserDELIMITERS, PostgreSQLParserDICTIONARY, PostgreSQLParserDISABLE_P, PostgreSQLParserDISCARD, PostgreSQLParserDOCUMENT_P, PostgreSQLParserDOMAIN_P, PostgreSQLParserDOUBLE_P, PostgreSQLParserDROP, PostgreSQLParserEACH, PostgreSQLParserENABLE_P, PostgreSQLParserENCODING, PostgreSQLParserENCRYPTED, PostgreSQLParserENUM_P, PostgreSQLParserESCAPE, PostgreSQLParserEVENT, PostgreSQLParserEXCLUDE, PostgreSQLParserEXCLUDING, PostgreSQLParserEXCLUSIVE, PostgreSQLParserEXECUTE, PostgreSQLParserEXPLAIN, PostgreSQLParserEXTENSION, PostgreSQLParserEXTERNAL, PostgreSQLParserFAMILY, PostgreSQLParserFIRST_P, PostgreSQLParserFOLLOWING, PostgreSQLParserFORCE, PostgreSQLParserFORWARD, PostgreSQLParserFUNCTION, PostgreSQLParserFUNCTIONS, PostgreSQLParserGLOBAL, PostgreSQLParserGRANTED, PostgreSQLParserHANDLER, PostgreSQLParserHEADER_P, PostgreSQLParserHOLD, PostgreSQLParserHOUR_P, PostgreSQLParserIDENTITY_P, PostgreSQLParserIF_P, PostgreSQLParserIMMEDIATE, PostgreSQLParserIMMUTABLE, PostgreSQLParserIMPLICIT_P, PostgreSQLParserINCLUDING, PostgreSQLParserINCREMENT, PostgreSQLParserINDEX, PostgreSQLParserINDEXES, PostgreSQLParserINHERIT, PostgreSQLParserINHERITS, PostgreSQLParserINLINE_P, PostgreSQLParserINSENSITIVE, PostgreSQLParserINSERT, PostgreSQLParserINSTEAD, PostgreSQLParserINVOKER, PostgreSQLParserISOLATION, PostgreSQLParserKEY, PostgreSQLParserLABEL, PostgreSQLParserLANGUAGE, PostgreSQLParserLARGE_P, PostgreSQLParserLAST_P, PostgreSQLParserLEAKPROOF, PostgreSQLParserLEVEL, PostgreSQLParserLISTEN, PostgreSQLParserLOAD, PostgreSQLParserLOCAL, PostgreSQLParserLOCATION, PostgreSQLParserLOCK_P, PostgreSQLParserMAPPING, PostgreSQLParserMATCH, PostgreSQLParserMATERIALIZED, PostgreSQLParserMAXVALUE, PostgreSQLParserMINUTE_P, PostgreSQLParserMINVALUE, PostgreSQLParserMODE, PostgreSQLParserMONTH_P, PostgreSQLParserMOVE, PostgreSQLParserNAME_P, PostgreSQLParserNAMES, PostgreSQLParserNEXT, PostgreSQLParserNO, PostgreSQLParserNOTHING, PostgreSQLParserNOTIFY, PostgreSQLParserNOWAIT, PostgreSQLParserNULLS_P, PostgreSQLParserOBJECT_P, PostgreSQLParserOF, PostgreSQLParserOFF, PostgreSQLParserOIDS, PostgreSQLParserOPERATOR, PostgreSQLParserOPTION, PostgreSQLParserOPTIONS, PostgreSQLParserOWNED, PostgreSQLParserOWNER, PostgreSQLParserPARSER, PostgreSQLParserPARTIAL, PostgreSQLParserPARTITION, PostgreSQLParserPASSING, PostgreSQLParserPASSWORD, PostgreSQLParserPLANS, PostgreSQLParserPRECEDING, PostgreSQLParserPREPARE, PostgreSQLParserPREPARED, PostgreSQLParserPRESERVE, PostgreSQLParserPRIOR, PostgreSQLParserPRIVILEGES, PostgreSQLParserPROCEDURAL, PostgreSQLParserPROCEDURE, PostgreSQLParserPROGRAM, PostgreSQLParserQUOTE, PostgreSQLParserRANGE, PostgreSQLParserREAD, PostgreSQLParserREASSIGN, PostgreSQLParserRECHECK, PostgreSQLParserRECURSIVE, PostgreSQLParserREF, PostgreSQLParserREFRESH, PostgreSQLParserREINDEX, PostgreSQLParserRELATIVE_P, PostgreSQLParserRELEASE, PostgreSQLParserRENAME, PostgreSQLParserREPEATABLE, PostgreSQLParserREPLACE, PostgreSQLParserREPLICA, PostgreSQLParserRESET, PostgreSQLParserRESTART, PostgreSQLParserRESTRICT, PostgreSQLParserRETURNS, PostgreSQLParserREVOKE, PostgreSQLParserROLE, PostgreSQLParserROLLBACK, PostgreSQLParserROWS, PostgreSQLParserRULE, PostgreSQLParserSAVEPOINT, PostgreSQLParserSCHEMA, PostgreSQLParserSCROLL, PostgreSQLParserSEARCH, PostgreSQLParserSECOND_P, PostgreSQLParserSECURITY, PostgreSQLParserSEQUENCE, PostgreSQLParserSEQUENCES, PostgreSQLParserSERIALIZABLE, PostgreSQLParserSERVER, PostgreSQLParserSESSION, PostgreSQLParserSET, PostgreSQLParserSHARE, PostgreSQLParserSHOW, PostgreSQLParserSIMPLE, PostgreSQLParserSNAPSHOT, PostgreSQLParserSTABLE, PostgreSQLParserSTANDALONE_P, PostgreSQLParserSTART, PostgreSQLParserSTATEMENT, PostgreSQLParserSTATISTICS, PostgreSQLParserSTDIN, PostgreSQLParserSTDOUT, PostgreSQLParserSTORAGE, PostgreSQLParserSTRICT_P, PostgreSQLParserSTRIP_P, PostgreSQLParserSYSID, PostgreSQLParserSYSTEM_P, PostgreSQLParserTABLES, PostgreSQLParserTABLESPACE, PostgreSQLParserTEMP, PostgreSQLParserTEMPLATE, PostgreSQLParserTEMPORARY, PostgreSQLParserTEXT_P, PostgreSQLParserTRANSACTION, PostgreSQLParserTRIGGER, PostgreSQLParserTRUNCATE, PostgreSQLParserTRUSTED, PostgreSQLParserTYPE_P, PostgreSQLParserTYPES_P, PostgreSQLParserUNBOUNDED, PostgreSQLParserUNCOMMITTED, PostgreSQLParserUNENCRYPTED, PostgreSQLParserUNKNOWN, PostgreSQLParserUNLISTEN, PostgreSQLParserUNLOGGED, PostgreSQLParserUNTIL, PostgreSQLParserUPDATE, PostgreSQLParserVACUUM, PostgreSQLParserVALID, PostgreSQLParserVALIDATE, PostgreSQLParserVALIDATOR, PostgreSQLParserVARYING, PostgreSQLParserVERSION_P, PostgreSQLParserVIEW, PostgreSQLParserVOLATILE, PostgreSQLParserWHITESPACE_P, PostgreSQLParserWITHOUT, PostgreSQLParserWORK, PostgreSQLParserWRAPPER, PostgreSQLParserWRITE, PostgreSQLParserXML_P, PostgreSQLParserYEAR_P, PostgreSQLParserYES_P, PostgreSQLParserZONE, PostgreSQLParserBETWEEN, PostgreSQLParserBIGINT, PostgreSQLParserBIT, PostgreSQLParserBOOLEAN_P, PostgreSQLParserCHAR_P, PostgreSQLParserCHARACTER, PostgreSQLParserCOALESCE, PostgreSQLParserDEC, PostgreSQLParserDECIMAL_P, PostgreSQLParserEXISTS, PostgreSQLParserEXTRACT, PostgreSQLParserFLOAT_P, PostgreSQLParserGREATEST, PostgreSQLParserINOUT, PostgreSQLParserINT_P, PostgreSQLParserINTEGER, PostgreSQLParserINTERVAL, PostgreSQLParserLEAST, PostgreSQLParserNATIONAL, PostgreSQLParserNCHAR, PostgreSQLParserNONE, PostgreSQLParserNULLIF, PostgreSQLParserNUMERIC, PostgreSQLParserOVERLAY, PostgreSQLParserPOSITION, PostgreSQLParserPRECISION, PostgreSQLParserREAL, PostgreSQLParserROW, PostgreSQLParserSETOF, PostgreSQLParserSMALLINT, PostgreSQLParserSUBSTRING, PostgreSQLParserTIME, PostgreSQLParserTIMESTAMP, PostgreSQLParserTREAT, PostgreSQLParserTRIM, PostgreSQLParserVALUES, PostgreSQLParserVARCHAR, PostgreSQLParserXMLATTRIBUTES, PostgreSQLParserXMLCOMMENT, PostgreSQLParserXMLAGG, PostgreSQLParserXML_IS_WELL_FORMED, PostgreSQLParserXML_IS_WELL_FORMED_DOCUMENT, PostgreSQLParserXML_IS_WELL_FORMED_CONTENT, PostgreSQLParserXPATH, PostgreSQLParserXPATH_EXISTS, PostgreSQLParserXMLCONCAT, PostgreSQLParserXMLELEMENT, PostgreSQLParserXMLEXISTS, PostgreSQLParserXMLFOREST, PostgreSQLParserXMLPARSE, PostgreSQLParserXMLPI, PostgreSQLParserXMLROOT, PostgreSQLParserXMLSERIALIZE, PostgreSQLParserCALL, PostgreSQLParserCURRENT_P, PostgreSQLParserATTACH, PostgreSQLParserDETACH, PostgreSQLParserEXPRESSION, PostgreSQLParserGENERATED, PostgreSQLParserLOGGED, PostgreSQLParserSTORED, PostgreSQLParserINCLUDE, PostgreSQLParserROUTINE, PostgreSQLParserTRANSFORM, PostgreSQLParserIMPORT_P, PostgreSQLParserPOLICY, PostgreSQLParserMETHOD, PostgreSQLParserREFERENCING, PostgreSQLParserNEW, PostgreSQLParserOLD, PostgreSQLParserVALUE_P, PostgreSQLParserSUBSCRIPTION, PostgreSQLParserPUBLICATION, PostgreSQLParserOUT_P, PostgreSQLParserROUTINES, PostgreSQLParserSCHEMAS, PostgreSQLParserPROCEDURES, PostgreSQLParserINPUT_P, PostgreSQLParserSUPPORT, PostgreSQLParserPARALLEL, PostgreSQLParserSQL_P, PostgreSQLParserDEPENDS, PostgreSQLParserOVERRIDING, PostgreSQLParserCONFLICT, PostgreSQLParserSKIP_P, PostgreSQLParserLOCKED, PostgreSQLParserTIES, PostgreSQLParserROLLUP, PostgreSQLParserCUBE, PostgreSQLParserGROUPING, PostgreSQLParserSETS, PostgreSQLParserTABLESAMPLE, PostgreSQLParserORDINALITY, PostgreSQLParserXMLTABLE, PostgreSQLParserCOLUMNS, PostgreSQLParserXMLNAMESPACES, PostgreSQLParserROWTYPE, PostgreSQLParserNORMALIZED, PostgreSQLParserWITHIN, PostgreSQLParserFILTER, PostgreSQLParserGROUPS, PostgreSQLParserOTHERS, PostgreSQLParserNFC, PostgreSQLParserNFD, PostgreSQLParserNFKC, PostgreSQLParserNFKD, PostgreSQLParserUESCAPE, PostgreSQLParserVIEWS, PostgreSQLParserNORMALIZE, PostgreSQLParserDUMP, PostgreSQLParserPRINT_STRICT_PARAMS, PostgreSQLParserVARIABLE_CONFLICT, PostgreSQLParserERROR, PostgreSQLParserUSE_VARIABLE, PostgreSQLParserUSE_COLUMN, PostgreSQLParserALIAS, PostgreSQLParserCONSTANT, PostgreSQLParserPERFORM, PostgreSQLParserGET, PostgreSQLParserDIAGNOSTICS, PostgreSQLParserSTACKED, PostgreSQLParserELSIF, PostgreSQLParserREVERSE, PostgreSQLParserSLICE, PostgreSQLParserEXIT, PostgreSQLParserRETURN, PostgreSQLParserQUERY, PostgreSQLParserRAISE, PostgreSQLParserSQLSTATE, PostgreSQLParserDEBUG, PostgreSQLParserLOG, PostgreSQLParserINFO, PostgreSQLParserNOTICE, PostgreSQLParserWARNING, PostgreSQLParserEXCEPTION, PostgreSQLParserASSERT, PostgreSQLParserOPEN, PostgreSQLParserABS, PostgreSQLParserCBRT, PostgreSQLParserCEIL, PostgreSQLParserCEILING, PostgreSQLParserDEGREES, PostgreSQLParserDIV, PostgreSQLParserEXP, PostgreSQLParserFACTORIAL, PostgreSQLParserFLOOR, PostgreSQLParserGCD, PostgreSQLParserLCM, PostgreSQLParserLN, PostgreSQLParserLOG10, PostgreSQLParserMIN_SCALE, PostgreSQLParserMOD, PostgreSQLParserPI, PostgreSQLParserPOWER, PostgreSQLParserRADIANS, PostgreSQLParserROUND, PostgreSQLParserSCALE, PostgreSQLParserSIGN, PostgreSQLParserSQRT, PostgreSQLParserTRIM_SCALE, PostgreSQLParserTRUNC, PostgreSQLParserWIDTH_BUCKET, PostgreSQLParserRANDOM, PostgreSQLParserSETSEED, PostgreSQLParserACOS, PostgreSQLParserACOSD, PostgreSQLParserASIN, PostgreSQLParserASIND, PostgreSQLParserATAN, PostgreSQLParserATAND, PostgreSQLParserATAN2, PostgreSQLParserATAN2D, PostgreSQLParserCOS, PostgreSQLParserCOSD, PostgreSQLParserCOT, PostgreSQLParserCOTD, PostgreSQLParserSIN, PostgreSQLParserSIND, PostgreSQLParserTAN, PostgreSQLParserTAND, PostgreSQLParserSINH, PostgreSQLParserCOSH, PostgreSQLParserTANH, PostgreSQLParserASINH, PostgreSQLParserACOSH, PostgreSQLParserATANH, PostgreSQLParserBIT_LENGTH, PostgreSQLParserCHAR_LENGTH, PostgreSQLParserCHARACTER_LENGTH, PostgreSQLParserLOWER, PostgreSQLParserOCTET_LENGTH, PostgreSQLParserUPPER, PostgreSQLParserASCII, PostgreSQLParserBTRIM, PostgreSQLParserCHR, PostgreSQLParserCONCAT, PostgreSQLParserCONCAT_WS, PostgreSQLParserFORMAT, PostgreSQLParserINITCAP, PostgreSQLParserLENGTH, PostgreSQLParserLPAD, PostgreSQLParserLTRIM, PostgreSQLParserMD5, PostgreSQLParserPARSE_IDENT, PostgreSQLParserPG_CLIENT_ENCODING, PostgreSQLParserQUOTE_IDENT, PostgreSQLParserQUOTE_LITERAL, PostgreSQLParserQUOTE_NULLABLE, PostgreSQLParserREGEXP_COUNT, PostgreSQLParserREGEXP_INSTR, PostgreSQLParserREGEXP_LIKE, PostgreSQLParserREGEXP_MATCH, PostgreSQLParserREGEXP_MATCHES, PostgreSQLParserREGEXP_REPLACE, PostgreSQLParserREGEXP_SPLIT_TO_ARRAY, PostgreSQLParserREGEXP_SPLIT_TO_TABLE, PostgreSQLParserREGEXP_SUBSTR, PostgreSQLParserREPEAT, PostgreSQLParserRPAD, PostgreSQLParserRTRIM, PostgreSQLParserSPLIT_PART, PostgreSQLParserSTARTS_WITH, PostgreSQLParserSTRING_TO_ARRAY, PostgreSQLParserSTRING_TO_TABLE, PostgreSQLParserSTRPOS, PostgreSQLParserSUBSTR, PostgreSQLParserTO_ASCII, PostgreSQLParserTO_HEX, PostgreSQLParserTRANSLATE, PostgreSQLParserUNISTR, PostgreSQLParserAGE, PostgreSQLParserCLOCK_TIMESTAMP, PostgreSQLParserDATE_BIN, PostgreSQLParserDATE_PART, PostgreSQLParserDATE_TRUNC, PostgreSQLParserISFINITE, PostgreSQLParserJUSTIFY_DAYS, PostgreSQLParserJUSTIFY_HOURS, PostgreSQLParserJUSTIFY_INTERVAL, PostgreSQLParserMAKE_DATE, PostgreSQLParserMAKE_INTERVAL, PostgreSQLParserMAKE_TIME, PostgreSQLParserMAKE_TIMESTAMP, PostgreSQLParserMAKE_TIMESTAMPTZ, PostgreSQLParserNOW, PostgreSQLParserSTATEMENT_TIMESTAMP, PostgreSQLParserTIMEOFDAY, PostgreSQLParserTRANSACTION_TIMESTAMP, PostgreSQLParserTO_TIMESTAMP, PostgreSQLParserTO_CHAR, PostgreSQLParserTO_DATE, PostgreSQLParserTO_NUMBER, PostgreSQLParserIdentifier, PostgreSQLParserQuotedIdentifier, PostgreSQLParserUnicodeQuotedIdentifier, PostgreSQLParserPLSQLVARIABLENAME, PostgreSQLParserPLSQLIDENTIFIER:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(3795)
			p.Rolespec()
		}

	case PostgreSQLParserUSER:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(3796)
			p.Match(PostgreSQLParserUSER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	default:
		p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IDropusermappingstmtContext is an interface to support dynamic dispatch.
type IDropusermappingstmtContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	DROP() antlr.TerminalNode
	USER() antlr.TerminalNode
	MAPPING() antlr.TerminalNode
	FOR() antlr.TerminalNode
	Auth_ident() IAuth_identContext
	SERVER() antlr.TerminalNode
	Name() INameContext
	IF_P() antlr.TerminalNode
	EXISTS() antlr.TerminalNode

	// IsDropusermappingstmtContext differentiates from other interfaces.
	IsDropusermappingstmtContext()
}

type DropusermappingstmtContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyDropusermappingstmtContext() *DropusermappingstmtContext {
	var p = new(DropusermappingstmtContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_dropusermappingstmt
	return p
}

func InitEmptyDropusermappingstmtContext(p *DropusermappingstmtContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_dropusermappingstmt
}

func (*DropusermappingstmtContext) IsDropusermappingstmtContext() {}

func NewDropusermappingstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DropusermappingstmtContext {
	var p = new(DropusermappingstmtContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_dropusermappingstmt

	return p
}

func (s *DropusermappingstmtContext) GetParser() antlr.Parser { return s.parser }

func (s *DropusermappingstmtContext) DROP() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserDROP, 0)
}

func (s *DropusermappingstmtContext) USER() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserUSER, 0)
}

func (s *DropusermappingstmtContext) MAPPING() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserMAPPING, 0)
}

func (s *DropusermappingstmtContext) FOR() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserFOR, 0)
}

func (s *DropusermappingstmtContext) Auth_ident() IAuth_identContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IAuth_identContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IAuth_identContext)
}

func (s *DropusermappingstmtContext) SERVER() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserSERVER, 0)
}

func (s *DropusermappingstmtContext) Name() INameContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(INameContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(INameContext)
}

func (s *DropusermappingstmtContext) IF_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserIF_P, 0)
}

func (s *DropusermappingstmtContext) EXISTS() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserEXISTS, 0)
}

func (s *DropusermappingstmtContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *DropusermappingstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *DropusermappingstmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterDropusermappingstmt(s)
	}
}

func (s *DropusermappingstmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitDropusermappingstmt(s)
	}
}

func (s *DropusermappingstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitDropusermappingstmt(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Dropusermappingstmt() (localctx IDropusermappingstmtContext) {
	localctx = NewDropusermappingstmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 378, PostgreSQLParserRULE_dropusermappingstmt)
	p.SetState(3817)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 172, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(3799)
			p.Match(PostgreSQLParserDROP)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(3800)
			p.Match(PostgreSQLParserUSER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(3801)
			p.Match(PostgreSQLParserMAPPING)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(3802)
			p.Match(PostgreSQLParserFOR)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(3803)
			p.Auth_ident()
		}
		{
			p.SetState(3804)
			p.Match(PostgreSQLParserSERVER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(3805)
			p.Name()
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(3807)
			p.Match(PostgreSQLParserDROP)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(3808)
			p.Match(PostgreSQLParserUSER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(3809)
			p.Match(PostgreSQLParserMAPPING)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(3810)
			p.Match(PostgreSQLParserIF_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(3811)
			p.Match(PostgreSQLParserEXISTS)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(3812)
			p.Match(PostgreSQLParserFOR)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(3813)
			p.Auth_ident()
		}
		{
			p.SetState(3814)
			p.Match(PostgreSQLParserSERVER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(3815)
			p.Name()
		}

	case antlr.ATNInvalidAltNumber:
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IAlterusermappingstmtContext is an interface to support dynamic dispatch.
type IAlterusermappingstmtContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	ALTER() antlr.TerminalNode
	USER() antlr.TerminalNode
	MAPPING() antlr.TerminalNode
	FOR() antlr.TerminalNode
	Auth_ident() IAuth_identContext
	SERVER() antlr.TerminalNode
	Name() INameContext
	Alter_generic_options() IAlter_generic_optionsContext

	// IsAlterusermappingstmtContext differentiates from other interfaces.
	IsAlterusermappingstmtContext()
}

type AlterusermappingstmtContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyAlterusermappingstmtContext() *AlterusermappingstmtContext {
	var p = new(AlterusermappingstmtContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_alterusermappingstmt
	return p
}

func InitEmptyAlterusermappingstmtContext(p *AlterusermappingstmtContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_alterusermappingstmt
}

func (*AlterusermappingstmtContext) IsAlterusermappingstmtContext() {}

func NewAlterusermappingstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AlterusermappingstmtContext {
	var p = new(AlterusermappingstmtContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_alterusermappingstmt

	return p
}

func (s *AlterusermappingstmtContext) GetParser() antlr.Parser { return s.parser }

func (s *AlterusermappingstmtContext) ALTER() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserALTER, 0)
}

func (s *AlterusermappingstmtContext) USER() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserUSER, 0)
}

func (s *AlterusermappingstmtContext) MAPPING() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserMAPPING, 0)
}

func (s *AlterusermappingstmtContext) FOR() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserFOR, 0)
}

func (s *AlterusermappingstmtContext) Auth_ident() IAuth_identContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IAuth_identContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IAuth_identContext)
}

func (s *AlterusermappingstmtContext) SERVER() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserSERVER, 0)
}

func (s *AlterusermappingstmtContext) Name() INameContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(INameContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(INameContext)
}

func (s *AlterusermappingstmtContext) Alter_generic_options() IAlter_generic_optionsContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IAlter_generic_optionsContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IAlter_generic_optionsContext)
}

func (s *AlterusermappingstmtContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *AlterusermappingstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *AlterusermappingstmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterAlterusermappingstmt(s)
	}
}

func (s *AlterusermappingstmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitAlterusermappingstmt(s)
	}
}

func (s *AlterusermappingstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitAlterusermappingstmt(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Alterusermappingstmt() (localctx IAlterusermappingstmtContext) {
	localctx = NewAlterusermappingstmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 380, PostgreSQLParserRULE_alterusermappingstmt)
	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(3819)
		p.Match(PostgreSQLParserALTER)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(3820)
		p.Match(PostgreSQLParserUSER)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(3821)
		p.Match(PostgreSQLParserMAPPING)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(3822)
		p.Match(PostgreSQLParserFOR)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(3823)
		p.Auth_ident()
	}
	{
		p.SetState(3824)
		p.Match(PostgreSQLParserSERVER)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(3825)
		p.Name()
	}
	{
		p.SetState(3826)
		p.Alter_generic_options()
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// ICreatepolicystmtContext is an interface to support dynamic dispatch.
type ICreatepolicystmtContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	CREATE() antlr.TerminalNode
	POLICY() antlr.TerminalNode
	Name() INameContext
	ON() antlr.TerminalNode
	Qualified_name() IQualified_nameContext
	Rowsecuritydefaultpermissive() IRowsecuritydefaultpermissiveContext
	Rowsecuritydefaultforcmd() IRowsecuritydefaultforcmdContext
	Rowsecuritydefaulttorole() IRowsecuritydefaulttoroleContext
	Rowsecurityoptionalexpr() IRowsecurityoptionalexprContext
	Rowsecurityoptionalwithcheck() IRowsecurityoptionalwithcheckContext

	// IsCreatepolicystmtContext differentiates from other interfaces.
	IsCreatepolicystmtContext()
}

type CreatepolicystmtContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyCreatepolicystmtContext() *CreatepolicystmtContext {
	var p = new(CreatepolicystmtContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_createpolicystmt
	return p
}

func InitEmptyCreatepolicystmtContext(p *CreatepolicystmtContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_createpolicystmt
}

func (*CreatepolicystmtContext) IsCreatepolicystmtContext() {}

func NewCreatepolicystmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CreatepolicystmtContext {
	var p = new(CreatepolicystmtContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_createpolicystmt

	return p
}

func (s *CreatepolicystmtContext) GetParser() antlr.Parser { return s.parser }

func (s *CreatepolicystmtContext) CREATE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCREATE, 0)
}

func (s *CreatepolicystmtContext) POLICY() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserPOLICY, 0)
}

func (s *CreatepolicystmtContext) Name() INameContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(INameContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(INameContext)
}

func (s *CreatepolicystmtContext) ON() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserON, 0)
}

func (s *CreatepolicystmtContext) Qualified_name() IQualified_nameContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IQualified_nameContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IQualified_nameContext)
}

func (s *CreatepolicystmtContext) Rowsecuritydefaultpermissive() IRowsecuritydefaultpermissiveContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IRowsecuritydefaultpermissiveContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IRowsecuritydefaultpermissiveContext)
}

func (s *CreatepolicystmtContext) Rowsecuritydefaultforcmd() IRowsecuritydefaultforcmdContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IRowsecuritydefaultforcmdContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IRowsecuritydefaultforcmdContext)
}

func (s *CreatepolicystmtContext) Rowsecuritydefaulttorole() IRowsecuritydefaulttoroleContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IRowsecuritydefaulttoroleContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IRowsecuritydefaulttoroleContext)
}

func (s *CreatepolicystmtContext) Rowsecurityoptionalexpr() IRowsecurityoptionalexprContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IRowsecurityoptionalexprContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IRowsecurityoptionalexprContext)
}

func (s *CreatepolicystmtContext) Rowsecurityoptionalwithcheck() IRowsecurityoptionalwithcheckContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IRowsecurityoptionalwithcheckContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IRowsecurityoptionalwithcheckContext)
}

func (s *CreatepolicystmtContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *CreatepolicystmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *CreatepolicystmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterCreatepolicystmt(s)
	}
}

func (s *CreatepolicystmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitCreatepolicystmt(s)
	}
}

func (s *CreatepolicystmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitCreatepolicystmt(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Createpolicystmt() (localctx ICreatepolicystmtContext) {
	localctx = NewCreatepolicystmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 382, PostgreSQLParserRULE_createpolicystmt)
	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(3828)
		p.Match(PostgreSQLParserCREATE)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(3829)
		p.Match(PostgreSQLParserPOLICY)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(3830)
		p.Name()
	}
	{
		p.SetState(3831)
		p.Match(PostgreSQLParserON)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(3832)
		p.Qualified_name()
	}
	{
		p.SetState(3833)
		p.Rowsecuritydefaultpermissive()
	}
	{
		p.SetState(3834)
		p.Rowsecuritydefaultforcmd()
	}
	{
		p.SetState(3835)
		p.Rowsecuritydefaulttorole()
	}
	{
		p.SetState(3836)
		p.Rowsecurityoptionalexpr()
	}
	{
		p.SetState(3837)
		p.Rowsecurityoptionalwithcheck()
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IAlterpolicystmtContext is an interface to support dynamic dispatch.
type IAlterpolicystmtContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	ALTER() antlr.TerminalNode
	POLICY() antlr.TerminalNode
	Name() INameContext
	ON() antlr.TerminalNode
	Qualified_name() IQualified_nameContext
	Rowsecurityoptionaltorole() IRowsecurityoptionaltoroleContext
	Rowsecurityoptionalexpr() IRowsecurityoptionalexprContext
	Rowsecurityoptionalwithcheck() IRowsecurityoptionalwithcheckContext

	// IsAlterpolicystmtContext differentiates from other interfaces.
	IsAlterpolicystmtContext()
}

type AlterpolicystmtContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyAlterpolicystmtContext() *AlterpolicystmtContext {
	var p = new(AlterpolicystmtContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_alterpolicystmt
	return p
}

func InitEmptyAlterpolicystmtContext(p *AlterpolicystmtContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_alterpolicystmt
}

func (*AlterpolicystmtContext) IsAlterpolicystmtContext() {}

func NewAlterpolicystmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AlterpolicystmtContext {
	var p = new(AlterpolicystmtContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_alterpolicystmt

	return p
}

func (s *AlterpolicystmtContext) GetParser() antlr.Parser { return s.parser }

func (s *AlterpolicystmtContext) ALTER() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserALTER, 0)
}

func (s *AlterpolicystmtContext) POLICY() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserPOLICY, 0)
}

func (s *AlterpolicystmtContext) Name() INameContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(INameContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(INameContext)
}

func (s *AlterpolicystmtContext) ON() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserON, 0)
}

func (s *AlterpolicystmtContext) Qualified_name() IQualified_nameContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IQualified_nameContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IQualified_nameContext)
}

func (s *AlterpolicystmtContext) Rowsecurityoptionaltorole() IRowsecurityoptionaltoroleContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IRowsecurityoptionaltoroleContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IRowsecurityoptionaltoroleContext)
}

func (s *AlterpolicystmtContext) Rowsecurityoptionalexpr() IRowsecurityoptionalexprContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IRowsecurityoptionalexprContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IRowsecurityoptionalexprContext)
}

func (s *AlterpolicystmtContext) Rowsecurityoptionalwithcheck() IRowsecurityoptionalwithcheckContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IRowsecurityoptionalwithcheckContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IRowsecurityoptionalwithcheckContext)
}

func (s *AlterpolicystmtContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *AlterpolicystmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *AlterpolicystmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterAlterpolicystmt(s)
	}
}

func (s *AlterpolicystmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitAlterpolicystmt(s)
	}
}

func (s *AlterpolicystmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitAlterpolicystmt(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Alterpolicystmt() (localctx IAlterpolicystmtContext) {
	localctx = NewAlterpolicystmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 384, PostgreSQLParserRULE_alterpolicystmt)
	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(3839)
		p.Match(PostgreSQLParserALTER)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(3840)
		p.Match(PostgreSQLParserPOLICY)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(3841)
		p.Name()
	}
	{
		p.SetState(3842)
		p.Match(PostgreSQLParserON)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(3843)
		p.Qualified_name()
	}
	{
		p.SetState(3844)
		p.Rowsecurityoptionaltorole()
	}
	{
		p.SetState(3845)
		p.Rowsecurityoptionalexpr()
	}
	{
		p.SetState(3846)
		p.Rowsecurityoptionalwithcheck()
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IRowsecurityoptionalexprContext is an interface to support dynamic dispatch.
type IRowsecurityoptionalexprContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	USING() antlr.TerminalNode
	OPEN_PAREN() antlr.TerminalNode
	A_expr() IA_exprContext
	CLOSE_PAREN() antlr.TerminalNode

	// IsRowsecurityoptionalexprContext differentiates from other interfaces.
	IsRowsecurityoptionalexprContext()
}

type RowsecurityoptionalexprContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyRowsecurityoptionalexprContext() *RowsecurityoptionalexprContext {
	var p = new(RowsecurityoptionalexprContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_rowsecurityoptionalexpr
	return p
}

func InitEmptyRowsecurityoptionalexprContext(p *RowsecurityoptionalexprContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_rowsecurityoptionalexpr
}

func (*RowsecurityoptionalexprContext) IsRowsecurityoptionalexprContext() {}

func NewRowsecurityoptionalexprContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *RowsecurityoptionalexprContext {
	var p = new(RowsecurityoptionalexprContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_rowsecurityoptionalexpr

	return p
}

func (s *RowsecurityoptionalexprContext) GetParser() antlr.Parser { return s.parser }

func (s *RowsecurityoptionalexprContext) USING() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserUSING, 0)
}

func (s *RowsecurityoptionalexprContext) OPEN_PAREN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserOPEN_PAREN, 0)
}

func (s *RowsecurityoptionalexprContext) A_expr() IA_exprContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IA_exprContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IA_exprContext)
}

func (s *RowsecurityoptionalexprContext) CLOSE_PAREN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCLOSE_PAREN, 0)
}

func (s *RowsecurityoptionalexprContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *RowsecurityoptionalexprContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *RowsecurityoptionalexprContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterRowsecurityoptionalexpr(s)
	}
}

func (s *RowsecurityoptionalexprContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitRowsecurityoptionalexpr(s)
	}
}

func (s *RowsecurityoptionalexprContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitRowsecurityoptionalexpr(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Rowsecurityoptionalexpr() (localctx IRowsecurityoptionalexprContext) {
	localctx = NewRowsecurityoptionalexprContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 386, PostgreSQLParserRULE_rowsecurityoptionalexpr)
	p.SetState(3854)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetTokenStream().LA(1) {
	case PostgreSQLParserUSING:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(3848)
			p.Match(PostgreSQLParserUSING)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(3849)
			p.Match(PostgreSQLParserOPEN_PAREN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(3850)
			p.A_expr()
		}
		{
			p.SetState(3851)
			p.Match(PostgreSQLParserCLOSE_PAREN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case PostgreSQLParserEOF, PostgreSQLParserOPEN_PAREN, PostgreSQLParserSEMI, PostgreSQLParserANALYSE, PostgreSQLParserANALYZE, PostgreSQLParserCREATE, PostgreSQLParserDO, PostgreSQLParserFETCH, PostgreSQLParserGRANT, PostgreSQLParserINTO, PostgreSQLParserSELECT, PostgreSQLParserTABLE, PostgreSQLParserWITH, PostgreSQLParserABORT_P, PostgreSQLParserALTER, PostgreSQLParserBEGIN_P, PostgreSQLParserCHECKPOINT, PostgreSQLParserCLOSE, PostgreSQLParserCLUSTER, PostgreSQLParserCOMMENT, PostgreSQLParserCOMMIT, PostgreSQLParserCOPY, PostgreSQLParserDEALLOCATE, PostgreSQLParserDECLARE, PostgreSQLParserDELETE_P, PostgreSQLParserDISCARD, PostgreSQLParserDROP, PostgreSQLParserEXECUTE, PostgreSQLParserEXPLAIN, PostgreSQLParserINSERT, PostgreSQLParserLISTEN, PostgreSQLParserLOAD, PostgreSQLParserLOCK_P, PostgreSQLParserMERGE, PostgreSQLParserMOVE, PostgreSQLParserNOTIFY, PostgreSQLParserPREPARE, PostgreSQLParserREASSIGN, PostgreSQLParserREFRESH, PostgreSQLParserREINDEX, PostgreSQLParserRELEASE, PostgreSQLParserRESET, PostgreSQLParserREVOKE, PostgreSQLParserROLLBACK, PostgreSQLParserSAVEPOINT, PostgreSQLParserSECURITY, PostgreSQLParserSET, PostgreSQLParserSHOW, PostgreSQLParserSTART, PostgreSQLParserTRUNCATE, PostgreSQLParserUNLISTEN, PostgreSQLParserUPDATE, PostgreSQLParserVACUUM, PostgreSQLParserVALUES, PostgreSQLParserCALL, PostgreSQLParserIMPORT_P, PostgreSQLParserEND_P, PostgreSQLParserMetaCommand:
		p.EnterOuterAlt(localctx, 2)

	default:
		p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IRowsecurityoptionalwithcheckContext is an interface to support dynamic dispatch.
type IRowsecurityoptionalwithcheckContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	WITH() antlr.TerminalNode
	CHECK() antlr.TerminalNode
	OPEN_PAREN() antlr.TerminalNode
	A_expr() IA_exprContext
	CLOSE_PAREN() antlr.TerminalNode

	// IsRowsecurityoptionalwithcheckContext differentiates from other interfaces.
	IsRowsecurityoptionalwithcheckContext()
}

type RowsecurityoptionalwithcheckContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyRowsecurityoptionalwithcheckContext() *RowsecurityoptionalwithcheckContext {
	var p = new(RowsecurityoptionalwithcheckContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_rowsecurityoptionalwithcheck
	return p
}

func InitEmptyRowsecurityoptionalwithcheckContext(p *RowsecurityoptionalwithcheckContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_rowsecurityoptionalwithcheck
}

func (*RowsecurityoptionalwithcheckContext) IsRowsecurityoptionalwithcheckContext() {}

func NewRowsecurityoptionalwithcheckContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *RowsecurityoptionalwithcheckContext {
	var p = new(RowsecurityoptionalwithcheckContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_rowsecurityoptionalwithcheck

	return p
}

func (s *RowsecurityoptionalwithcheckContext) GetParser() antlr.Parser { return s.parser }

func (s *RowsecurityoptionalwithcheckContext) WITH() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserWITH, 0)
}

func (s *RowsecurityoptionalwithcheckContext) CHECK() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCHECK, 0)
}

func (s *RowsecurityoptionalwithcheckContext) OPEN_PAREN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserOPEN_PAREN, 0)
}

func (s *RowsecurityoptionalwithcheckContext) A_expr() IA_exprContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IA_exprContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IA_exprContext)
}

func (s *RowsecurityoptionalwithcheckContext) CLOSE_PAREN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCLOSE_PAREN, 0)
}

func (s *RowsecurityoptionalwithcheckContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *RowsecurityoptionalwithcheckContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *RowsecurityoptionalwithcheckContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterRowsecurityoptionalwithcheck(s)
	}
}

func (s *RowsecurityoptionalwithcheckContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitRowsecurityoptionalwithcheck(s)
	}
}

func (s *RowsecurityoptionalwithcheckContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitRowsecurityoptionalwithcheck(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Rowsecurityoptionalwithcheck() (localctx IRowsecurityoptionalwithcheckContext) {
	localctx = NewRowsecurityoptionalwithcheckContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 388, PostgreSQLParserRULE_rowsecurityoptionalwithcheck)
	p.SetState(3863)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 174, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(3856)
			p.Match(PostgreSQLParserWITH)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(3857)
			p.Match(PostgreSQLParserCHECK)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(3858)
			p.Match(PostgreSQLParserOPEN_PAREN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(3859)
			p.A_expr()
		}
		{
			p.SetState(3860)
			p.Match(PostgreSQLParserCLOSE_PAREN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)

	case antlr.ATNInvalidAltNumber:
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IRowsecuritydefaulttoroleContext is an interface to support dynamic dispatch.
type IRowsecuritydefaulttoroleContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	TO() antlr.TerminalNode
	Role_list() IRole_listContext

	// IsRowsecuritydefaulttoroleContext differentiates from other interfaces.
	IsRowsecuritydefaulttoroleContext()
}

type RowsecuritydefaulttoroleContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyRowsecuritydefaulttoroleContext() *RowsecuritydefaulttoroleContext {
	var p = new(RowsecuritydefaulttoroleContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_rowsecuritydefaulttorole
	return p
}

func InitEmptyRowsecuritydefaulttoroleContext(p *RowsecuritydefaulttoroleContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_rowsecuritydefaulttorole
}

func (*RowsecuritydefaulttoroleContext) IsRowsecuritydefaulttoroleContext() {}

func NewRowsecuritydefaulttoroleContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *RowsecuritydefaulttoroleContext {
	var p = new(RowsecuritydefaulttoroleContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_rowsecuritydefaulttorole

	return p
}

func (s *RowsecuritydefaulttoroleContext) GetParser() antlr.Parser { return s.parser }

func (s *RowsecuritydefaulttoroleContext) TO() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserTO, 0)
}

func (s *RowsecuritydefaulttoroleContext) Role_list() IRole_listContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IRole_listContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IRole_listContext)
}

func (s *RowsecuritydefaulttoroleContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *RowsecuritydefaulttoroleContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *RowsecuritydefaulttoroleContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterRowsecuritydefaulttorole(s)
	}
}

func (s *RowsecuritydefaulttoroleContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitRowsecuritydefaulttorole(s)
	}
}

func (s *RowsecuritydefaulttoroleContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitRowsecuritydefaulttorole(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Rowsecuritydefaulttorole() (localctx IRowsecuritydefaulttoroleContext) {
	localctx = NewRowsecuritydefaulttoroleContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 390, PostgreSQLParserRULE_rowsecuritydefaulttorole)
	p.SetState(3868)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetTokenStream().LA(1) {
	case PostgreSQLParserTO:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(3865)
			p.Match(PostgreSQLParserTO)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(3866)
			p.Role_list()
		}

	case PostgreSQLParserEOF, PostgreSQLParserOPEN_PAREN, PostgreSQLParserSEMI, PostgreSQLParserANALYSE, PostgreSQLParserANALYZE, PostgreSQLParserCREATE, PostgreSQLParserDO, PostgreSQLParserFETCH, PostgreSQLParserGRANT, PostgreSQLParserINTO, PostgreSQLParserSELECT, PostgreSQLParserTABLE, PostgreSQLParserUSING, PostgreSQLParserWITH, PostgreSQLParserABORT_P, PostgreSQLParserALTER, PostgreSQLParserBEGIN_P, PostgreSQLParserCHECKPOINT, PostgreSQLParserCLOSE, PostgreSQLParserCLUSTER, PostgreSQLParserCOMMENT, PostgreSQLParserCOMMIT, PostgreSQLParserCOPY, PostgreSQLParserDEALLOCATE, PostgreSQLParserDECLARE, PostgreSQLParserDELETE_P, PostgreSQLParserDISCARD, PostgreSQLParserDROP, PostgreSQLParserEXECUTE, PostgreSQLParserEXPLAIN, PostgreSQLParserINSERT, PostgreSQLParserLISTEN, PostgreSQLParserLOAD, PostgreSQLParserLOCK_P, PostgreSQLParserMERGE, PostgreSQLParserMOVE, PostgreSQLParserNOTIFY, PostgreSQLParserPREPARE, PostgreSQLParserREASSIGN, PostgreSQLParserREFRESH, PostgreSQLParserREINDEX, PostgreSQLParserRELEASE, PostgreSQLParserRESET, PostgreSQLParserREVOKE, PostgreSQLParserROLLBACK, PostgreSQLParserSAVEPOINT, PostgreSQLParserSECURITY, PostgreSQLParserSET, PostgreSQLParserSHOW, PostgreSQLParserSTART, PostgreSQLParserTRUNCATE, PostgreSQLParserUNLISTEN, PostgreSQLParserUPDATE, PostgreSQLParserVACUUM, PostgreSQLParserVALUES, PostgreSQLParserCALL, PostgreSQLParserIMPORT_P, PostgreSQLParserEND_P, PostgreSQLParserMetaCommand:
		p.EnterOuterAlt(localctx, 2)

	default:
		p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IRowsecurityoptionaltoroleContext is an interface to support dynamic dispatch.
type IRowsecurityoptionaltoroleContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	TO() antlr.TerminalNode
	Role_list() IRole_listContext

	// IsRowsecurityoptionaltoroleContext differentiates from other interfaces.
	IsRowsecurityoptionaltoroleContext()
}

type RowsecurityoptionaltoroleContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyRowsecurityoptionaltoroleContext() *RowsecurityoptionaltoroleContext {
	var p = new(RowsecurityoptionaltoroleContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_rowsecurityoptionaltorole
	return p
}

func InitEmptyRowsecurityoptionaltoroleContext(p *RowsecurityoptionaltoroleContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_rowsecurityoptionaltorole
}

func (*RowsecurityoptionaltoroleContext) IsRowsecurityoptionaltoroleContext() {}

func NewRowsecurityoptionaltoroleContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *RowsecurityoptionaltoroleContext {
	var p = new(RowsecurityoptionaltoroleContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_rowsecurityoptionaltorole

	return p
}

func (s *RowsecurityoptionaltoroleContext) GetParser() antlr.Parser { return s.parser }

func (s *RowsecurityoptionaltoroleContext) TO() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserTO, 0)
}

func (s *RowsecurityoptionaltoroleContext) Role_list() IRole_listContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IRole_listContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IRole_listContext)
}

func (s *RowsecurityoptionaltoroleContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *RowsecurityoptionaltoroleContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *RowsecurityoptionaltoroleContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterRowsecurityoptionaltorole(s)
	}
}

func (s *RowsecurityoptionaltoroleContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitRowsecurityoptionaltorole(s)
	}
}

func (s *RowsecurityoptionaltoroleContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitRowsecurityoptionaltorole(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Rowsecurityoptionaltorole() (localctx IRowsecurityoptionaltoroleContext) {
	localctx = NewRowsecurityoptionaltoroleContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 392, PostgreSQLParserRULE_rowsecurityoptionaltorole)
	p.SetState(3873)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetTokenStream().LA(1) {
	case PostgreSQLParserTO:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(3870)
			p.Match(PostgreSQLParserTO)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(3871)
			p.Role_list()
		}

	case PostgreSQLParserEOF, PostgreSQLParserOPEN_PAREN, PostgreSQLParserSEMI, PostgreSQLParserANALYSE, PostgreSQLParserANALYZE, PostgreSQLParserCREATE, PostgreSQLParserDO, PostgreSQLParserFETCH, PostgreSQLParserGRANT, PostgreSQLParserINTO, PostgreSQLParserSELECT, PostgreSQLParserTABLE, PostgreSQLParserUSING, PostgreSQLParserWITH, PostgreSQLParserABORT_P, PostgreSQLParserALTER, PostgreSQLParserBEGIN_P, PostgreSQLParserCHECKPOINT, PostgreSQLParserCLOSE, PostgreSQLParserCLUSTER, PostgreSQLParserCOMMENT, PostgreSQLParserCOMMIT, PostgreSQLParserCOPY, PostgreSQLParserDEALLOCATE, PostgreSQLParserDECLARE, PostgreSQLParserDELETE_P, PostgreSQLParserDISCARD, PostgreSQLParserDROP, PostgreSQLParserEXECUTE, PostgreSQLParserEXPLAIN, PostgreSQLParserINSERT, PostgreSQLParserLISTEN, PostgreSQLParserLOAD, PostgreSQLParserLOCK_P, PostgreSQLParserMERGE, PostgreSQLParserMOVE, PostgreSQLParserNOTIFY, PostgreSQLParserPREPARE, PostgreSQLParserREASSIGN, PostgreSQLParserREFRESH, PostgreSQLParserREINDEX, PostgreSQLParserRELEASE, PostgreSQLParserRESET, PostgreSQLParserREVOKE, PostgreSQLParserROLLBACK, PostgreSQLParserSAVEPOINT, PostgreSQLParserSECURITY, PostgreSQLParserSET, PostgreSQLParserSHOW, PostgreSQLParserSTART, PostgreSQLParserTRUNCATE, PostgreSQLParserUNLISTEN, PostgreSQLParserUPDATE, PostgreSQLParserVACUUM, PostgreSQLParserVALUES, PostgreSQLParserCALL, PostgreSQLParserIMPORT_P, PostgreSQLParserEND_P, PostgreSQLParserMetaCommand:
		p.EnterOuterAlt(localctx, 2)

	default:
		p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IRowsecuritydefaultpermissiveContext is an interface to support dynamic dispatch.
type IRowsecuritydefaultpermissiveContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	AS() antlr.TerminalNode
	Identifier() IIdentifierContext

	// IsRowsecuritydefaultpermissiveContext differentiates from other interfaces.
	IsRowsecuritydefaultpermissiveContext()
}

type RowsecuritydefaultpermissiveContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyRowsecuritydefaultpermissiveContext() *RowsecuritydefaultpermissiveContext {
	var p = new(RowsecuritydefaultpermissiveContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_rowsecuritydefaultpermissive
	return p
}

func InitEmptyRowsecuritydefaultpermissiveContext(p *RowsecuritydefaultpermissiveContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_rowsecuritydefaultpermissive
}

func (*RowsecuritydefaultpermissiveContext) IsRowsecuritydefaultpermissiveContext() {}

func NewRowsecuritydefaultpermissiveContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *RowsecuritydefaultpermissiveContext {
	var p = new(RowsecuritydefaultpermissiveContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_rowsecuritydefaultpermissive

	return p
}

func (s *RowsecuritydefaultpermissiveContext) GetParser() antlr.Parser { return s.parser }

func (s *RowsecuritydefaultpermissiveContext) AS() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserAS, 0)
}

func (s *RowsecuritydefaultpermissiveContext) Identifier() IIdentifierContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IIdentifierContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IIdentifierContext)
}

func (s *RowsecuritydefaultpermissiveContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *RowsecuritydefaultpermissiveContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *RowsecuritydefaultpermissiveContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterRowsecuritydefaultpermissive(s)
	}
}

func (s *RowsecuritydefaultpermissiveContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitRowsecuritydefaultpermissive(s)
	}
}

func (s *RowsecuritydefaultpermissiveContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitRowsecuritydefaultpermissive(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Rowsecuritydefaultpermissive() (localctx IRowsecuritydefaultpermissiveContext) {
	localctx = NewRowsecuritydefaultpermissiveContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 394, PostgreSQLParserRULE_rowsecuritydefaultpermissive)
	p.SetState(3878)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetTokenStream().LA(1) {
	case PostgreSQLParserAS:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(3875)
			p.Match(PostgreSQLParserAS)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(3876)
			p.Identifier()
		}

	case PostgreSQLParserEOF, PostgreSQLParserOPEN_PAREN, PostgreSQLParserSEMI, PostgreSQLParserANALYSE, PostgreSQLParserANALYZE, PostgreSQLParserCREATE, PostgreSQLParserDO, PostgreSQLParserFETCH, PostgreSQLParserFOR, PostgreSQLParserGRANT, PostgreSQLParserINTO, PostgreSQLParserSELECT, PostgreSQLParserTABLE, PostgreSQLParserTO, PostgreSQLParserUSING, PostgreSQLParserWITH, PostgreSQLParserABORT_P, PostgreSQLParserALTER, PostgreSQLParserBEGIN_P, PostgreSQLParserCHECKPOINT, PostgreSQLParserCLOSE, PostgreSQLParserCLUSTER, PostgreSQLParserCOMMENT, PostgreSQLParserCOMMIT, PostgreSQLParserCOPY, PostgreSQLParserDEALLOCATE, PostgreSQLParserDECLARE, PostgreSQLParserDELETE_P, PostgreSQLParserDISCARD, PostgreSQLParserDROP, PostgreSQLParserEXECUTE, PostgreSQLParserEXPLAIN, PostgreSQLParserINSERT, PostgreSQLParserLISTEN, PostgreSQLParserLOAD, PostgreSQLParserLOCK_P, PostgreSQLParserMERGE, PostgreSQLParserMOVE, PostgreSQLParserNOTIFY, PostgreSQLParserPREPARE, PostgreSQLParserREASSIGN, PostgreSQLParserREFRESH, PostgreSQLParserREINDEX, PostgreSQLParserRELEASE, PostgreSQLParserRESET, PostgreSQLParserREVOKE, PostgreSQLParserROLLBACK, PostgreSQLParserSAVEPOINT, PostgreSQLParserSECURITY, PostgreSQLParserSET, PostgreSQLParserSHOW, PostgreSQLParserSTART, PostgreSQLParserTRUNCATE, PostgreSQLParserUNLISTEN, PostgreSQLParserUPDATE, PostgreSQLParserVACUUM, PostgreSQLParserVALUES, PostgreSQLParserCALL, PostgreSQLParserIMPORT_P, PostgreSQLParserEND_P, PostgreSQLParserMetaCommand:
		p.EnterOuterAlt(localctx, 2)

	default:
		p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IRowsecuritydefaultforcmdContext is an interface to support dynamic dispatch.
type IRowsecuritydefaultforcmdContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	FOR() antlr.TerminalNode
	Row_security_cmd() IRow_security_cmdContext

	// IsRowsecuritydefaultforcmdContext differentiates from other interfaces.
	IsRowsecuritydefaultforcmdContext()
}

type RowsecuritydefaultforcmdContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyRowsecuritydefaultforcmdContext() *RowsecuritydefaultforcmdContext {
	var p = new(RowsecuritydefaultforcmdContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_rowsecuritydefaultforcmd
	return p
}

func InitEmptyRowsecuritydefaultforcmdContext(p *RowsecuritydefaultforcmdContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_rowsecuritydefaultforcmd
}

func (*RowsecuritydefaultforcmdContext) IsRowsecuritydefaultforcmdContext() {}

func NewRowsecuritydefaultforcmdContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *RowsecuritydefaultforcmdContext {
	var p = new(RowsecuritydefaultforcmdContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_rowsecuritydefaultforcmd

	return p
}

func (s *RowsecuritydefaultforcmdContext) GetParser() antlr.Parser { return s.parser }

func (s *RowsecuritydefaultforcmdContext) FOR() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserFOR, 0)
}

func (s *RowsecuritydefaultforcmdContext) Row_security_cmd() IRow_security_cmdContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IRow_security_cmdContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IRow_security_cmdContext)
}

func (s *RowsecuritydefaultforcmdContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *RowsecuritydefaultforcmdContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *RowsecuritydefaultforcmdContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterRowsecuritydefaultforcmd(s)
	}
}

func (s *RowsecuritydefaultforcmdContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitRowsecuritydefaultforcmd(s)
	}
}

func (s *RowsecuritydefaultforcmdContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitRowsecuritydefaultforcmd(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Rowsecuritydefaultforcmd() (localctx IRowsecuritydefaultforcmdContext) {
	localctx = NewRowsecuritydefaultforcmdContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 396, PostgreSQLParserRULE_rowsecuritydefaultforcmd)
	p.SetState(3883)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetTokenStream().LA(1) {
	case PostgreSQLParserFOR:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(3880)
			p.Match(PostgreSQLParserFOR)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(3881)
			p.Row_security_cmd()
		}

	case PostgreSQLParserEOF, PostgreSQLParserOPEN_PAREN, PostgreSQLParserSEMI, PostgreSQLParserANALYSE, PostgreSQLParserANALYZE, PostgreSQLParserCREATE, PostgreSQLParserDO, PostgreSQLParserFETCH, PostgreSQLParserGRANT, PostgreSQLParserINTO, PostgreSQLParserSELECT, PostgreSQLParserTABLE, PostgreSQLParserTO, PostgreSQLParserUSING, PostgreSQLParserWITH, PostgreSQLParserABORT_P, PostgreSQLParserALTER, PostgreSQLParserBEGIN_P, PostgreSQLParserCHECKPOINT, PostgreSQLParserCLOSE, PostgreSQLParserCLUSTER, PostgreSQLParserCOMMENT, PostgreSQLParserCOMMIT, PostgreSQLParserCOPY, PostgreSQLParserDEALLOCATE, PostgreSQLParserDECLARE, PostgreSQLParserDELETE_P, PostgreSQLParserDISCARD, PostgreSQLParserDROP, PostgreSQLParserEXECUTE, PostgreSQLParserEXPLAIN, PostgreSQLParserINSERT, PostgreSQLParserLISTEN, PostgreSQLParserLOAD, PostgreSQLParserLOCK_P, PostgreSQLParserMERGE, PostgreSQLParserMOVE, PostgreSQLParserNOTIFY, PostgreSQLParserPREPARE, PostgreSQLParserREASSIGN, PostgreSQLParserREFRESH, PostgreSQLParserREINDEX, PostgreSQLParserRELEASE, PostgreSQLParserRESET, PostgreSQLParserREVOKE, PostgreSQLParserROLLBACK, PostgreSQLParserSAVEPOINT, PostgreSQLParserSECURITY, PostgreSQLParserSET, PostgreSQLParserSHOW, PostgreSQLParserSTART, PostgreSQLParserTRUNCATE, PostgreSQLParserUNLISTEN, PostgreSQLParserUPDATE, PostgreSQLParserVACUUM, PostgreSQLParserVALUES, PostgreSQLParserCALL, PostgreSQLParserIMPORT_P, PostgreSQLParserEND_P, PostgreSQLParserMetaCommand:
		p.EnterOuterAlt(localctx, 2)

	default:
		p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IRow_security_cmdContext is an interface to support dynamic dispatch.
type IRow_security_cmdContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	ALL() antlr.TerminalNode
	SELECT() antlr.TerminalNode
	INSERT() antlr.TerminalNode
	UPDATE() antlr.TerminalNode
	DELETE_P() antlr.TerminalNode

	// IsRow_security_cmdContext differentiates from other interfaces.
	IsRow_security_cmdContext()
}

type Row_security_cmdContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyRow_security_cmdContext() *Row_security_cmdContext {
	var p = new(Row_security_cmdContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_row_security_cmd
	return p
}

func InitEmptyRow_security_cmdContext(p *Row_security_cmdContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_row_security_cmd
}

func (*Row_security_cmdContext) IsRow_security_cmdContext() {}

func NewRow_security_cmdContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Row_security_cmdContext {
	var p = new(Row_security_cmdContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_row_security_cmd

	return p
}

func (s *Row_security_cmdContext) GetParser() antlr.Parser { return s.parser }

func (s *Row_security_cmdContext) ALL() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserALL, 0)
}

func (s *Row_security_cmdContext) SELECT() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserSELECT, 0)
}

func (s *Row_security_cmdContext) INSERT() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserINSERT, 0)
}

func (s *Row_security_cmdContext) UPDATE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserUPDATE, 0)
}

func (s *Row_security_cmdContext) DELETE_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserDELETE_P, 0)
}

func (s *Row_security_cmdContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Row_security_cmdContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Row_security_cmdContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterRow_security_cmd(s)
	}
}

func (s *Row_security_cmdContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitRow_security_cmd(s)
	}
}

func (s *Row_security_cmdContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitRow_security_cmd(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Row_security_cmd() (localctx IRow_security_cmdContext) {
	localctx = NewRow_security_cmdContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 398, PostgreSQLParserRULE_row_security_cmd)
	var _la int

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(3885)
		_la = p.GetTokenStream().LA(1)

		if !(_la == PostgreSQLParserALL || _la == PostgreSQLParserSELECT || _la == PostgreSQLParserDELETE_P || _la == PostgreSQLParserINSERT || _la == PostgreSQLParserUPDATE) {
			p.GetErrorHandler().RecoverInline(p)
		} else {
			p.GetErrorHandler().ReportMatch(p)
			p.Consume()
		}
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// ICreateamstmtContext is an interface to support dynamic dispatch.
type ICreateamstmtContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	CREATE() antlr.TerminalNode
	ACCESS() antlr.TerminalNode
	METHOD() antlr.TerminalNode
	Name() INameContext
	TYPE_P() antlr.TerminalNode
	Am_type() IAm_typeContext
	HANDLER() antlr.TerminalNode
	Handler_name() IHandler_nameContext

	// IsCreateamstmtContext differentiates from other interfaces.
	IsCreateamstmtContext()
}

type CreateamstmtContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyCreateamstmtContext() *CreateamstmtContext {
	var p = new(CreateamstmtContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_createamstmt
	return p
}

func InitEmptyCreateamstmtContext(p *CreateamstmtContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_createamstmt
}

func (*CreateamstmtContext) IsCreateamstmtContext() {}

func NewCreateamstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CreateamstmtContext {
	var p = new(CreateamstmtContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_createamstmt

	return p
}

func (s *CreateamstmtContext) GetParser() antlr.Parser { return s.parser }

func (s *CreateamstmtContext) CREATE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCREATE, 0)
}

func (s *CreateamstmtContext) ACCESS() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserACCESS, 0)
}

func (s *CreateamstmtContext) METHOD() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserMETHOD, 0)
}

func (s *CreateamstmtContext) Name() INameContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(INameContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(INameContext)
}

func (s *CreateamstmtContext) TYPE_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserTYPE_P, 0)
}

func (s *CreateamstmtContext) Am_type() IAm_typeContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IAm_typeContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IAm_typeContext)
}

func (s *CreateamstmtContext) HANDLER() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserHANDLER, 0)
}

func (s *CreateamstmtContext) Handler_name() IHandler_nameContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IHandler_nameContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IHandler_nameContext)
}

func (s *CreateamstmtContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *CreateamstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *CreateamstmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterCreateamstmt(s)
	}
}

func (s *CreateamstmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitCreateamstmt(s)
	}
}

func (s *CreateamstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitCreateamstmt(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Createamstmt() (localctx ICreateamstmtContext) {
	localctx = NewCreateamstmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 400, PostgreSQLParserRULE_createamstmt)
	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(3887)
		p.Match(PostgreSQLParserCREATE)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(3888)
		p.Match(PostgreSQLParserACCESS)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(3889)
		p.Match(PostgreSQLParserMETHOD)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(3890)
		p.Name()
	}
	{
		p.SetState(3891)
		p.Match(PostgreSQLParserTYPE_P)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(3892)
		p.Am_type()
	}
	{
		p.SetState(3893)
		p.Match(PostgreSQLParserHANDLER)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(3894)
		p.Handler_name()
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IAm_typeContext is an interface to support dynamic dispatch.
type IAm_typeContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	INDEX() antlr.TerminalNode
	TABLE() antlr.TerminalNode

	// IsAm_typeContext differentiates from other interfaces.
	IsAm_typeContext()
}

type Am_typeContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyAm_typeContext() *Am_typeContext {
	var p = new(Am_typeContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_am_type
	return p
}

func InitEmptyAm_typeContext(p *Am_typeContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_am_type
}

func (*Am_typeContext) IsAm_typeContext() {}

func NewAm_typeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Am_typeContext {
	var p = new(Am_typeContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_am_type

	return p
}

func (s *Am_typeContext) GetParser() antlr.Parser { return s.parser }

func (s *Am_typeContext) INDEX() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserINDEX, 0)
}

func (s *Am_typeContext) TABLE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserTABLE, 0)
}

func (s *Am_typeContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Am_typeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Am_typeContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterAm_type(s)
	}
}

func (s *Am_typeContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitAm_type(s)
	}
}

func (s *Am_typeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitAm_type(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Am_type() (localctx IAm_typeContext) {
	localctx = NewAm_typeContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 402, PostgreSQLParserRULE_am_type)
	var _la int

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(3896)
		_la = p.GetTokenStream().LA(1)

		if !(_la == PostgreSQLParserTABLE || _la == PostgreSQLParserINDEX) {
			p.GetErrorHandler().RecoverInline(p)
		} else {
			p.GetErrorHandler().ReportMatch(p)
			p.Consume()
		}
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// ICreatetrigstmtContext is an interface to support dynamic dispatch.
type ICreatetrigstmtContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	CREATE() antlr.TerminalNode
	TRIGGER() antlr.TerminalNode
	Name() INameContext
	Triggeractiontime() ITriggeractiontimeContext
	Triggerevents() ITriggereventsContext
	ON() antlr.TerminalNode
	Qualified_name() IQualified_nameContext
	Triggerreferencing() ITriggerreferencingContext
	Triggerforspec() ITriggerforspecContext
	Triggerwhen() ITriggerwhenContext
	EXECUTE() antlr.TerminalNode
	Function_or_procedure() IFunction_or_procedureContext
	Func_name() IFunc_nameContext
	OPEN_PAREN() antlr.TerminalNode
	Triggerfuncargs() ITriggerfuncargsContext
	CLOSE_PAREN() antlr.TerminalNode
	CONSTRAINT() antlr.TerminalNode
	AFTER() antlr.TerminalNode
	Optconstrfromtable() IOptconstrfromtableContext
	Constraintattributespec() IConstraintattributespecContext
	FOR() antlr.TerminalNode
	EACH() antlr.TerminalNode
	ROW() antlr.TerminalNode

	// IsCreatetrigstmtContext differentiates from other interfaces.
	IsCreatetrigstmtContext()
}

type CreatetrigstmtContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyCreatetrigstmtContext() *CreatetrigstmtContext {
	var p = new(CreatetrigstmtContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_createtrigstmt
	return p
}

func InitEmptyCreatetrigstmtContext(p *CreatetrigstmtContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_createtrigstmt
}

func (*CreatetrigstmtContext) IsCreatetrigstmtContext() {}

func NewCreatetrigstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CreatetrigstmtContext {
	var p = new(CreatetrigstmtContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_createtrigstmt

	return p
}

func (s *CreatetrigstmtContext) GetParser() antlr.Parser { return s.parser }

func (s *CreatetrigstmtContext) CREATE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCREATE, 0)
}

func (s *CreatetrigstmtContext) TRIGGER() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserTRIGGER, 0)
}

func (s *CreatetrigstmtContext) Name() INameContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(INameContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(INameContext)
}

func (s *CreatetrigstmtContext) Triggeractiontime() ITriggeractiontimeContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ITriggeractiontimeContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ITriggeractiontimeContext)
}

func (s *CreatetrigstmtContext) Triggerevents() ITriggereventsContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ITriggereventsContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ITriggereventsContext)
}

func (s *CreatetrigstmtContext) ON() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserON, 0)
}

func (s *CreatetrigstmtContext) Qualified_name() IQualified_nameContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IQualified_nameContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IQualified_nameContext)
}

func (s *CreatetrigstmtContext) Triggerreferencing() ITriggerreferencingContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ITriggerreferencingContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ITriggerreferencingContext)
}

func (s *CreatetrigstmtContext) Triggerforspec() ITriggerforspecContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ITriggerforspecContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ITriggerforspecContext)
}

func (s *CreatetrigstmtContext) Triggerwhen() ITriggerwhenContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ITriggerwhenContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ITriggerwhenContext)
}

func (s *CreatetrigstmtContext) EXECUTE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserEXECUTE, 0)
}

func (s *CreatetrigstmtContext) Function_or_procedure() IFunction_or_procedureContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IFunction_or_procedureContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IFunction_or_procedureContext)
}

func (s *CreatetrigstmtContext) Func_name() IFunc_nameContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IFunc_nameContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IFunc_nameContext)
}

func (s *CreatetrigstmtContext) OPEN_PAREN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserOPEN_PAREN, 0)
}

func (s *CreatetrigstmtContext) Triggerfuncargs() ITriggerfuncargsContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ITriggerfuncargsContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ITriggerfuncargsContext)
}

func (s *CreatetrigstmtContext) CLOSE_PAREN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCLOSE_PAREN, 0)
}

func (s *CreatetrigstmtContext) CONSTRAINT() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCONSTRAINT, 0)
}

func (s *CreatetrigstmtContext) AFTER() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserAFTER, 0)
}

func (s *CreatetrigstmtContext) Optconstrfromtable() IOptconstrfromtableContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOptconstrfromtableContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOptconstrfromtableContext)
}

func (s *CreatetrigstmtContext) Constraintattributespec() IConstraintattributespecContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IConstraintattributespecContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IConstraintattributespecContext)
}

func (s *CreatetrigstmtContext) FOR() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserFOR, 0)
}

func (s *CreatetrigstmtContext) EACH() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserEACH, 0)
}

func (s *CreatetrigstmtContext) ROW() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserROW, 0)
}

func (s *CreatetrigstmtContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *CreatetrigstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *CreatetrigstmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterCreatetrigstmt(s)
	}
}

func (s *CreatetrigstmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitCreatetrigstmt(s)
	}
}

func (s *CreatetrigstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitCreatetrigstmt(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Createtrigstmt() (localctx ICreatetrigstmtContext) {
	localctx = NewCreatetrigstmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 404, PostgreSQLParserRULE_createtrigstmt)
	p.SetState(3936)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 179, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(3898)
			p.Match(PostgreSQLParserCREATE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(3899)
			p.Match(PostgreSQLParserTRIGGER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(3900)
			p.Name()
		}
		{
			p.SetState(3901)
			p.Triggeractiontime()
		}
		{
			p.SetState(3902)
			p.Triggerevents()
		}
		{
			p.SetState(3903)
			p.Match(PostgreSQLParserON)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(3904)
			p.Qualified_name()
		}
		{
			p.SetState(3905)
			p.Triggerreferencing()
		}
		{
			p.SetState(3906)
			p.Triggerforspec()
		}
		{
			p.SetState(3907)
			p.Triggerwhen()
		}
		{
			p.SetState(3908)
			p.Match(PostgreSQLParserEXECUTE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(3909)
			p.Function_or_procedure()
		}
		{
			p.SetState(3910)
			p.Func_name()
		}
		{
			p.SetState(3911)
			p.Match(PostgreSQLParserOPEN_PAREN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(3912)
			p.Triggerfuncargs()
		}
		{
			p.SetState(3913)
			p.Match(PostgreSQLParserCLOSE_PAREN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(3915)
			p.Match(PostgreSQLParserCREATE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(3916)
			p.Match(PostgreSQLParserCONSTRAINT)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(3917)
			p.Match(PostgreSQLParserTRIGGER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(3918)
			p.Name()
		}
		{
			p.SetState(3919)
			p.Match(PostgreSQLParserAFTER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(3920)
			p.Triggerevents()
		}
		{
			p.SetState(3921)
			p.Match(PostgreSQLParserON)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(3922)
			p.Qualified_name()
		}
		{
			p.SetState(3923)
			p.Optconstrfromtable()
		}
		{
			p.SetState(3924)
			p.Constraintattributespec()
		}
		{
			p.SetState(3925)
			p.Match(PostgreSQLParserFOR)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(3926)
			p.Match(PostgreSQLParserEACH)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(3927)
			p.Match(PostgreSQLParserROW)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(3928)
			p.Triggerwhen()
		}
		{
			p.SetState(3929)
			p.Match(PostgreSQLParserEXECUTE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(3930)
			p.Function_or_procedure()
		}
		{
			p.SetState(3931)
			p.Func_name()
		}
		{
			p.SetState(3932)
			p.Match(PostgreSQLParserOPEN_PAREN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(3933)
			p.Triggerfuncargs()
		}
		{
			p.SetState(3934)
			p.Match(PostgreSQLParserCLOSE_PAREN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case antlr.ATNInvalidAltNumber:
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// ITriggeractiontimeContext is an interface to support dynamic dispatch.
type ITriggeractiontimeContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	BEFORE() antlr.TerminalNode
	AFTER() antlr.TerminalNode
	INSTEAD() antlr.TerminalNode
	OF() antlr.TerminalNode

	// IsTriggeractiontimeContext differentiates from other interfaces.
	IsTriggeractiontimeContext()
}

type TriggeractiontimeContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyTriggeractiontimeContext() *TriggeractiontimeContext {
	var p = new(TriggeractiontimeContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_triggeractiontime
	return p
}

func InitEmptyTriggeractiontimeContext(p *TriggeractiontimeContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_triggeractiontime
}

func (*TriggeractiontimeContext) IsTriggeractiontimeContext() {}

func NewTriggeractiontimeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TriggeractiontimeContext {
	var p = new(TriggeractiontimeContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_triggeractiontime

	return p
}

func (s *TriggeractiontimeContext) GetParser() antlr.Parser { return s.parser }

func (s *TriggeractiontimeContext) BEFORE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserBEFORE, 0)
}

func (s *TriggeractiontimeContext) AFTER() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserAFTER, 0)
}

func (s *TriggeractiontimeContext) INSTEAD() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserINSTEAD, 0)
}

func (s *TriggeractiontimeContext) OF() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserOF, 0)
}

func (s *TriggeractiontimeContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *TriggeractiontimeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *TriggeractiontimeContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterTriggeractiontime(s)
	}
}

func (s *TriggeractiontimeContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitTriggeractiontime(s)
	}
}

func (s *TriggeractiontimeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitTriggeractiontime(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Triggeractiontime() (localctx ITriggeractiontimeContext) {
	localctx = NewTriggeractiontimeContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 406, PostgreSQLParserRULE_triggeractiontime)
	p.SetState(3942)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetTokenStream().LA(1) {
	case PostgreSQLParserBEFORE:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(3938)
			p.Match(PostgreSQLParserBEFORE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case PostgreSQLParserAFTER:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(3939)
			p.Match(PostgreSQLParserAFTER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case PostgreSQLParserINSTEAD:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(3940)
			p.Match(PostgreSQLParserINSTEAD)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(3941)
			p.Match(PostgreSQLParserOF)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	default:
		p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// ITriggereventsContext is an interface to support dynamic dispatch.
type ITriggereventsContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	AllTriggeroneevent() []ITriggeroneeventContext
	Triggeroneevent(i int) ITriggeroneeventContext
	AllOR() []antlr.TerminalNode
	OR(i int) antlr.TerminalNode

	// IsTriggereventsContext differentiates from other interfaces.
	IsTriggereventsContext()
}

type TriggereventsContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyTriggereventsContext() *TriggereventsContext {
	var p = new(TriggereventsContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_triggerevents
	return p
}

func InitEmptyTriggereventsContext(p *TriggereventsContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_triggerevents
}

func (*TriggereventsContext) IsTriggereventsContext() {}

func NewTriggereventsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TriggereventsContext {
	var p = new(TriggereventsContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_triggerevents

	return p
}

func (s *TriggereventsContext) GetParser() antlr.Parser { return s.parser }

func (s *TriggereventsContext) AllTriggeroneevent() []ITriggeroneeventContext {
	children := s.GetChildren()
	len := 0
	for _, ctx := range children {
		if _, ok := ctx.(ITriggeroneeventContext); ok {
			len++
		}
	}

	tst := make([]ITriggeroneeventContext, len)
	i := 0
	for _, ctx := range children {
		if t, ok := ctx.(ITriggeroneeventContext); ok {
			tst[i] = t.(ITriggeroneeventContext)
			i++
		}
	}

	return tst
}

func (s *TriggereventsContext) Triggeroneevent(i int) ITriggeroneeventContext {
	var t antlr.RuleContext
	j := 0
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ITriggeroneeventContext); ok {
			if j == i {
				t = ctx.(antlr.RuleContext)
				break
			}
			j++
		}
	}

	if t == nil {
		return nil
	}

	return t.(ITriggeroneeventContext)
}

func (s *TriggereventsContext) AllOR() []antlr.TerminalNode {
	return s.GetTokens(PostgreSQLParserOR)
}

func (s *TriggereventsContext) OR(i int) antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserOR, i)
}

func (s *TriggereventsContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *TriggereventsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *TriggereventsContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterTriggerevents(s)
	}
}

func (s *TriggereventsContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitTriggerevents(s)
	}
}

func (s *TriggereventsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitTriggerevents(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Triggerevents() (localctx ITriggereventsContext) {
	localctx = NewTriggereventsContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 408, PostgreSQLParserRULE_triggerevents)
	var _la int

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(3944)
		p.Triggeroneevent()
	}
	p.SetState(3949)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}
	_la = p.GetTokenStream().LA(1)

	for _la == PostgreSQLParserOR {
		{
			p.SetState(3945)
			p.Match(PostgreSQLParserOR)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(3946)
			p.Triggeroneevent()
		}

		p.SetState(3951)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}
		_la = p.GetTokenStream().LA(1)
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// ITriggeroneeventContext is an interface to support dynamic dispatch.
type ITriggeroneeventContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	INSERT() antlr.TerminalNode
	DELETE_P() antlr.TerminalNode
	UPDATE() antlr.TerminalNode
	OF() antlr.TerminalNode
	Columnlist() IColumnlistContext
	TRUNCATE() antlr.TerminalNode

	// IsTriggeroneeventContext differentiates from other interfaces.
	IsTriggeroneeventContext()
}

type TriggeroneeventContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyTriggeroneeventContext() *TriggeroneeventContext {
	var p = new(TriggeroneeventContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_triggeroneevent
	return p
}

func InitEmptyTriggeroneeventContext(p *TriggeroneeventContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_triggeroneevent
}

func (*TriggeroneeventContext) IsTriggeroneeventContext() {}

func NewTriggeroneeventContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TriggeroneeventContext {
	var p = new(TriggeroneeventContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_triggeroneevent

	return p
}

func (s *TriggeroneeventContext) GetParser() antlr.Parser { return s.parser }

func (s *TriggeroneeventContext) INSERT() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserINSERT, 0)
}

func (s *TriggeroneeventContext) DELETE_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserDELETE_P, 0)
}

func (s *TriggeroneeventContext) UPDATE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserUPDATE, 0)
}

func (s *TriggeroneeventContext) OF() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserOF, 0)
}

func (s *TriggeroneeventContext) Columnlist() IColumnlistContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IColumnlistContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IColumnlistContext)
}

func (s *TriggeroneeventContext) TRUNCATE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserTRUNCATE, 0)
}

func (s *TriggeroneeventContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *TriggeroneeventContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *TriggeroneeventContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterTriggeroneevent(s)
	}
}

func (s *TriggeroneeventContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitTriggeroneevent(s)
	}
}

func (s *TriggeroneeventContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitTriggeroneevent(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Triggeroneevent() (localctx ITriggeroneeventContext) {
	localctx = NewTriggeroneeventContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 410, PostgreSQLParserRULE_triggeroneevent)
	p.SetState(3959)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 182, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(3952)
			p.Match(PostgreSQLParserINSERT)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(3953)
			p.Match(PostgreSQLParserDELETE_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 3:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(3954)
			p.Match(PostgreSQLParserUPDATE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 4:
		p.EnterOuterAlt(localctx, 4)
		{
			p.SetState(3955)
			p.Match(PostgreSQLParserUPDATE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(3956)
			p.Match(PostgreSQLParserOF)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(3957)
			p.Columnlist()
		}

	case 5:
		p.EnterOuterAlt(localctx, 5)
		{
			p.SetState(3958)
			p.Match(PostgreSQLParserTRUNCATE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case antlr.ATNInvalidAltNumber:
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// ITriggerreferencingContext is an interface to support dynamic dispatch.
type ITriggerreferencingContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	REFERENCING() antlr.TerminalNode
	Triggertransitions() ITriggertransitionsContext

	// IsTriggerreferencingContext differentiates from other interfaces.
	IsTriggerreferencingContext()
}

type TriggerreferencingContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyTriggerreferencingContext() *TriggerreferencingContext {
	var p = new(TriggerreferencingContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_triggerreferencing
	return p
}

func InitEmptyTriggerreferencingContext(p *TriggerreferencingContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_triggerreferencing
}

func (*TriggerreferencingContext) IsTriggerreferencingContext() {}

func NewTriggerreferencingContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TriggerreferencingContext {
	var p = new(TriggerreferencingContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_triggerreferencing

	return p
}

func (s *TriggerreferencingContext) GetParser() antlr.Parser { return s.parser }

func (s *TriggerreferencingContext) REFERENCING() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserREFERENCING, 0)
}

func (s *TriggerreferencingContext) Triggertransitions() ITriggertransitionsContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ITriggertransitionsContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ITriggertransitionsContext)
}

func (s *TriggerreferencingContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *TriggerreferencingContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *TriggerreferencingContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterTriggerreferencing(s)
	}
}

func (s *TriggerreferencingContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitTriggerreferencing(s)
	}
}

func (s *TriggerreferencingContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitTriggerreferencing(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Triggerreferencing() (localctx ITriggerreferencingContext) {
	localctx = NewTriggerreferencingContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 412, PostgreSQLParserRULE_triggerreferencing)
	p.SetState(3964)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetTokenStream().LA(1) {
	case PostgreSQLParserREFERENCING:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(3961)
			p.Match(PostgreSQLParserREFERENCING)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(3962)
			p.Triggertransitions()
		}

	case PostgreSQLParserFOR, PostgreSQLParserWHEN, PostgreSQLParserEXECUTE:
		p.EnterOuterAlt(localctx, 2)

	default:
		p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// ITriggertransitionsContext is an interface to support dynamic dispatch.
type ITriggertransitionsContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	AllTriggertransition() []ITriggertransitionContext
	Triggertransition(i int) ITriggertransitionContext

	// IsTriggertransitionsContext differentiates from other interfaces.
	IsTriggertransitionsContext()
}

type TriggertransitionsContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyTriggertransitionsContext() *TriggertransitionsContext {
	var p = new(TriggertransitionsContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_triggertransitions
	return p
}

func InitEmptyTriggertransitionsContext(p *TriggertransitionsContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_triggertransitions
}

func (*TriggertransitionsContext) IsTriggertransitionsContext() {}

func NewTriggertransitionsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TriggertransitionsContext {
	var p = new(TriggertransitionsContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_triggertransitions

	return p
}

func (s *TriggertransitionsContext) GetParser() antlr.Parser { return s.parser }

func (s *TriggertransitionsContext) AllTriggertransition() []ITriggertransitionContext {
	children := s.GetChildren()
	len := 0
	for _, ctx := range children {
		if _, ok := ctx.(ITriggertransitionContext); ok {
			len++
		}
	}

	tst := make([]ITriggertransitionContext, len)
	i := 0
	for _, ctx := range children {
		if t, ok := ctx.(ITriggertransitionContext); ok {
			tst[i] = t.(ITriggertransitionContext)
			i++
		}
	}

	return tst
}

func (s *TriggertransitionsContext) Triggertransition(i int) ITriggertransitionContext {
	var t antlr.RuleContext
	j := 0
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ITriggertransitionContext); ok {
			if j == i {
				t = ctx.(antlr.RuleContext)
				break
			}
			j++
		}
	}

	if t == nil {
		return nil
	}

	return t.(ITriggertransitionContext)
}

func (s *TriggertransitionsContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *TriggertransitionsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *TriggertransitionsContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterTriggertransitions(s)
	}
}

func (s *TriggertransitionsContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitTriggertransitions(s)
	}
}

func (s *TriggertransitionsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitTriggertransitions(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Triggertransitions() (localctx ITriggertransitionsContext) {
	localctx = NewTriggertransitionsContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 414, PostgreSQLParserRULE_triggertransitions)
	var _la int

	p.EnterOuterAlt(localctx, 1)
	p.SetState(3967)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}
	_la = p.GetTokenStream().LA(1)

	for ok := true; ok; ok = _la == PostgreSQLParserNEW || _la == PostgreSQLParserOLD {
		{
			p.SetState(3966)
			p.Triggertransition()
		}

		p.SetState(3969)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}
		_la = p.GetTokenStream().LA(1)
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// ITriggertransitionContext is an interface to support dynamic dispatch.
type ITriggertransitionContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Transitionoldornew() ITransitionoldornewContext
	Transitionrowortable() ITransitionrowortableContext
	Opt_as() IOpt_asContext
	Transitionrelname() ITransitionrelnameContext

	// IsTriggertransitionContext differentiates from other interfaces.
	IsTriggertransitionContext()
}

type TriggertransitionContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyTriggertransitionContext() *TriggertransitionContext {
	var p = new(TriggertransitionContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_triggertransition
	return p
}

func InitEmptyTriggertransitionContext(p *TriggertransitionContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_triggertransition
}

func (*TriggertransitionContext) IsTriggertransitionContext() {}

func NewTriggertransitionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TriggertransitionContext {
	var p = new(TriggertransitionContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_triggertransition

	return p
}

func (s *TriggertransitionContext) GetParser() antlr.Parser { return s.parser }

func (s *TriggertransitionContext) Transitionoldornew() ITransitionoldornewContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ITransitionoldornewContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ITransitionoldornewContext)
}

func (s *TriggertransitionContext) Transitionrowortable() ITransitionrowortableContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ITransitionrowortableContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ITransitionrowortableContext)
}

func (s *TriggertransitionContext) Opt_as() IOpt_asContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOpt_asContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOpt_asContext)
}

func (s *TriggertransitionContext) Transitionrelname() ITransitionrelnameContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ITransitionrelnameContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ITransitionrelnameContext)
}

func (s *TriggertransitionContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *TriggertransitionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *TriggertransitionContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterTriggertransition(s)
	}
}

func (s *TriggertransitionContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitTriggertransition(s)
	}
}

func (s *TriggertransitionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitTriggertransition(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Triggertransition() (localctx ITriggertransitionContext) {
	localctx = NewTriggertransitionContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 416, PostgreSQLParserRULE_triggertransition)
	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(3971)
		p.Transitionoldornew()
	}
	{
		p.SetState(3972)
		p.Transitionrowortable()
	}
	{
		p.SetState(3973)
		p.Opt_as()
	}
	{
		p.SetState(3974)
		p.Transitionrelname()
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// ITransitionoldornewContext is an interface to support dynamic dispatch.
type ITransitionoldornewContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	NEW() antlr.TerminalNode
	OLD() antlr.TerminalNode

	// IsTransitionoldornewContext differentiates from other interfaces.
	IsTransitionoldornewContext()
}

type TransitionoldornewContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyTransitionoldornewContext() *TransitionoldornewContext {
	var p = new(TransitionoldornewContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_transitionoldornew
	return p
}

func InitEmptyTransitionoldornewContext(p *TransitionoldornewContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_transitionoldornew
}

func (*TransitionoldornewContext) IsTransitionoldornewContext() {}

func NewTransitionoldornewContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TransitionoldornewContext {
	var p = new(TransitionoldornewContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_transitionoldornew

	return p
}

func (s *TransitionoldornewContext) GetParser() antlr.Parser { return s.parser }

func (s *TransitionoldornewContext) NEW() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserNEW, 0)
}

func (s *TransitionoldornewContext) OLD() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserOLD, 0)
}

func (s *TransitionoldornewContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *TransitionoldornewContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *TransitionoldornewContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterTransitionoldornew(s)
	}
}

func (s *TransitionoldornewContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitTransitionoldornew(s)
	}
}

func (s *TransitionoldornewContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitTransitionoldornew(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Transitionoldornew() (localctx ITransitionoldornewContext) {
	localctx = NewTransitionoldornewContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 418, PostgreSQLParserRULE_transitionoldornew)
	var _la int

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(3976)
		_la = p.GetTokenStream().LA(1)

		if !(_la == PostgreSQLParserNEW || _la == PostgreSQLParserOLD) {
			p.GetErrorHandler().RecoverInline(p)
		} else {
			p.GetErrorHandler().ReportMatch(p)
			p.Consume()
		}
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// ITransitionrowortableContext is an interface to support dynamic dispatch.
type ITransitionrowortableContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	TABLE() antlr.TerminalNode
	ROW() antlr.TerminalNode

	// IsTransitionrowortableContext differentiates from other interfaces.
	IsTransitionrowortableContext()
}

type TransitionrowortableContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyTransitionrowortableContext() *TransitionrowortableContext {
	var p = new(TransitionrowortableContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_transitionrowortable
	return p
}

func InitEmptyTransitionrowortableContext(p *TransitionrowortableContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_transitionrowortable
}

func (*TransitionrowortableContext) IsTransitionrowortableContext() {}

func NewTransitionrowortableContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TransitionrowortableContext {
	var p = new(TransitionrowortableContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_transitionrowortable

	return p
}

func (s *TransitionrowortableContext) GetParser() antlr.Parser { return s.parser }

func (s *TransitionrowortableContext) TABLE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserTABLE, 0)
}

func (s *TransitionrowortableContext) ROW() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserROW, 0)
}

func (s *TransitionrowortableContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *TransitionrowortableContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *TransitionrowortableContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterTransitionrowortable(s)
	}
}

func (s *TransitionrowortableContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitTransitionrowortable(s)
	}
}

func (s *TransitionrowortableContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitTransitionrowortable(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Transitionrowortable() (localctx ITransitionrowortableContext) {
	localctx = NewTransitionrowortableContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 420, PostgreSQLParserRULE_transitionrowortable)
	var _la int

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(3978)
		_la = p.GetTokenStream().LA(1)

		if !(_la == PostgreSQLParserTABLE || _la == PostgreSQLParserROW) {
			p.GetErrorHandler().RecoverInline(p)
		} else {
			p.GetErrorHandler().ReportMatch(p)
			p.Consume()
		}
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// ITransitionrelnameContext is an interface to support dynamic dispatch.
type ITransitionrelnameContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Colid() IColidContext

	// IsTransitionrelnameContext differentiates from other interfaces.
	IsTransitionrelnameContext()
}

type TransitionrelnameContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyTransitionrelnameContext() *TransitionrelnameContext {
	var p = new(TransitionrelnameContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_transitionrelname
	return p
}

func InitEmptyTransitionrelnameContext(p *TransitionrelnameContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_transitionrelname
}

func (*TransitionrelnameContext) IsTransitionrelnameContext() {}

func NewTransitionrelnameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TransitionrelnameContext {
	var p = new(TransitionrelnameContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_transitionrelname

	return p
}

func (s *TransitionrelnameContext) GetParser() antlr.Parser { return s.parser }

func (s *TransitionrelnameContext) Colid() IColidContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IColidContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IColidContext)
}

func (s *TransitionrelnameContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *TransitionrelnameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *TransitionrelnameContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterTransitionrelname(s)
	}
}

func (s *TransitionrelnameContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitTransitionrelname(s)
	}
}

func (s *TransitionrelnameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitTransitionrelname(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Transitionrelname() (localctx ITransitionrelnameContext) {
	localctx = NewTransitionrelnameContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 422, PostgreSQLParserRULE_transitionrelname)
	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(3980)
		p.Colid()
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// ITriggerforspecContext is an interface to support dynamic dispatch.
type ITriggerforspecContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	FOR() antlr.TerminalNode
	Triggerforopteach() ITriggerforopteachContext
	Triggerfortype() ITriggerfortypeContext

	// IsTriggerforspecContext differentiates from other interfaces.
	IsTriggerforspecContext()
}

type TriggerforspecContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyTriggerforspecContext() *TriggerforspecContext {
	var p = new(TriggerforspecContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_triggerforspec
	return p
}

func InitEmptyTriggerforspecContext(p *TriggerforspecContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_triggerforspec
}

func (*TriggerforspecContext) IsTriggerforspecContext() {}

func NewTriggerforspecContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TriggerforspecContext {
	var p = new(TriggerforspecContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_triggerforspec

	return p
}

func (s *TriggerforspecContext) GetParser() antlr.Parser { return s.parser }

func (s *TriggerforspecContext) FOR() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserFOR, 0)
}

func (s *TriggerforspecContext) Triggerforopteach() ITriggerforopteachContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ITriggerforopteachContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ITriggerforopteachContext)
}

func (s *TriggerforspecContext) Triggerfortype() ITriggerfortypeContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ITriggerfortypeContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ITriggerfortypeContext)
}

func (s *TriggerforspecContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *TriggerforspecContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *TriggerforspecContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterTriggerforspec(s)
	}
}

func (s *TriggerforspecContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitTriggerforspec(s)
	}
}

func (s *TriggerforspecContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitTriggerforspec(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Triggerforspec() (localctx ITriggerforspecContext) {
	localctx = NewTriggerforspecContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 424, PostgreSQLParserRULE_triggerforspec)
	p.SetState(3987)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetTokenStream().LA(1) {
	case PostgreSQLParserFOR:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(3982)
			p.Match(PostgreSQLParserFOR)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(3983)
			p.Triggerforopteach()
		}
		{
			p.SetState(3984)
			p.Triggerfortype()
		}

	case PostgreSQLParserWHEN, PostgreSQLParserEXECUTE:
		p.EnterOuterAlt(localctx, 2)

	default:
		p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// ITriggerforopteachContext is an interface to support dynamic dispatch.
type ITriggerforopteachContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	EACH() antlr.TerminalNode

	// IsTriggerforopteachContext differentiates from other interfaces.
	IsTriggerforopteachContext()
}

type TriggerforopteachContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyTriggerforopteachContext() *TriggerforopteachContext {
	var p = new(TriggerforopteachContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_triggerforopteach
	return p
}

func InitEmptyTriggerforopteachContext(p *TriggerforopteachContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_triggerforopteach
}

func (*TriggerforopteachContext) IsTriggerforopteachContext() {}

func NewTriggerforopteachContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TriggerforopteachContext {
	var p = new(TriggerforopteachContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_triggerforopteach

	return p
}

func (s *TriggerforopteachContext) GetParser() antlr.Parser { return s.parser }

func (s *TriggerforopteachContext) EACH() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserEACH, 0)
}

func (s *TriggerforopteachContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *TriggerforopteachContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *TriggerforopteachContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterTriggerforopteach(s)
	}
}

func (s *TriggerforopteachContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitTriggerforopteach(s)
	}
}

func (s *TriggerforopteachContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitTriggerforopteach(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Triggerforopteach() (localctx ITriggerforopteachContext) {
	localctx = NewTriggerforopteachContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 426, PostgreSQLParserRULE_triggerforopteach)
	p.SetState(3991)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetTokenStream().LA(1) {
	case PostgreSQLParserEACH:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(3989)
			p.Match(PostgreSQLParserEACH)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case PostgreSQLParserSTATEMENT, PostgreSQLParserROW:
		p.EnterOuterAlt(localctx, 2)

	default:
		p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// ITriggerfortypeContext is an interface to support dynamic dispatch.
type ITriggerfortypeContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	ROW() antlr.TerminalNode
	STATEMENT() antlr.TerminalNode

	// IsTriggerfortypeContext differentiates from other interfaces.
	IsTriggerfortypeContext()
}

type TriggerfortypeContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyTriggerfortypeContext() *TriggerfortypeContext {
	var p = new(TriggerfortypeContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_triggerfortype
	return p
}

func InitEmptyTriggerfortypeContext(p *TriggerfortypeContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_triggerfortype
}

func (*TriggerfortypeContext) IsTriggerfortypeContext() {}

func NewTriggerfortypeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TriggerfortypeContext {
	var p = new(TriggerfortypeContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_triggerfortype

	return p
}

func (s *TriggerfortypeContext) GetParser() antlr.Parser { return s.parser }

func (s *TriggerfortypeContext) ROW() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserROW, 0)
}

func (s *TriggerfortypeContext) STATEMENT() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserSTATEMENT, 0)
}

func (s *TriggerfortypeContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *TriggerfortypeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *TriggerfortypeContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterTriggerfortype(s)
	}
}

func (s *TriggerfortypeContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitTriggerfortype(s)
	}
}

func (s *TriggerfortypeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitTriggerfortype(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Triggerfortype() (localctx ITriggerfortypeContext) {
	localctx = NewTriggerfortypeContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 428, PostgreSQLParserRULE_triggerfortype)
	var _la int

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(3993)
		_la = p.GetTokenStream().LA(1)

		if !(_la == PostgreSQLParserSTATEMENT || _la == PostgreSQLParserROW) {
			p.GetErrorHandler().RecoverInline(p)
		} else {
			p.GetErrorHandler().ReportMatch(p)
			p.Consume()
		}
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// ITriggerwhenContext is an interface to support dynamic dispatch.
type ITriggerwhenContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	WHEN() antlr.TerminalNode
	OPEN_PAREN() antlr.TerminalNode
	A_expr() IA_exprContext
	CLOSE_PAREN() antlr.TerminalNode

	// IsTriggerwhenContext differentiates from other interfaces.
	IsTriggerwhenContext()
}

type TriggerwhenContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyTriggerwhenContext() *TriggerwhenContext {
	var p = new(TriggerwhenContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_triggerwhen
	return p
}

func InitEmptyTriggerwhenContext(p *TriggerwhenContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_triggerwhen
}

func (*TriggerwhenContext) IsTriggerwhenContext() {}

func NewTriggerwhenContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TriggerwhenContext {
	var p = new(TriggerwhenContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_triggerwhen

	return p
}

func (s *TriggerwhenContext) GetParser() antlr.Parser { return s.parser }

func (s *TriggerwhenContext) WHEN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserWHEN, 0)
}

func (s *TriggerwhenContext) OPEN_PAREN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserOPEN_PAREN, 0)
}

func (s *TriggerwhenContext) A_expr() IA_exprContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IA_exprContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IA_exprContext)
}

func (s *TriggerwhenContext) CLOSE_PAREN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCLOSE_PAREN, 0)
}

func (s *TriggerwhenContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *TriggerwhenContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *TriggerwhenContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterTriggerwhen(s)
	}
}

func (s *TriggerwhenContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitTriggerwhen(s)
	}
}

func (s *TriggerwhenContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitTriggerwhen(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Triggerwhen() (localctx ITriggerwhenContext) {
	localctx = NewTriggerwhenContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 430, PostgreSQLParserRULE_triggerwhen)
	p.SetState(4001)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetTokenStream().LA(1) {
	case PostgreSQLParserWHEN:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(3995)
			p.Match(PostgreSQLParserWHEN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(3996)
			p.Match(PostgreSQLParserOPEN_PAREN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(3997)
			p.A_expr()
		}
		{
			p.SetState(3998)
			p.Match(PostgreSQLParserCLOSE_PAREN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case PostgreSQLParserEXECUTE:
		p.EnterOuterAlt(localctx, 2)

	default:
		p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IFunction_or_procedureContext is an interface to support dynamic dispatch.
type IFunction_or_procedureContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	FUNCTION() antlr.TerminalNode
	PROCEDURE() antlr.TerminalNode

	// IsFunction_or_procedureContext differentiates from other interfaces.
	IsFunction_or_procedureContext()
}

type Function_or_procedureContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyFunction_or_procedureContext() *Function_or_procedureContext {
	var p = new(Function_or_procedureContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_function_or_procedure
	return p
}

func InitEmptyFunction_or_procedureContext(p *Function_or_procedureContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_function_or_procedure
}

func (*Function_or_procedureContext) IsFunction_or_procedureContext() {}

func NewFunction_or_procedureContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Function_or_procedureContext {
	var p = new(Function_or_procedureContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_function_or_procedure

	return p
}

func (s *Function_or_procedureContext) GetParser() antlr.Parser { return s.parser }

func (s *Function_or_procedureContext) FUNCTION() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserFUNCTION, 0)
}

func (s *Function_or_procedureContext) PROCEDURE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserPROCEDURE, 0)
}

func (s *Function_or_procedureContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Function_or_procedureContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Function_or_procedureContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterFunction_or_procedure(s)
	}
}

func (s *Function_or_procedureContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitFunction_or_procedure(s)
	}
}

func (s *Function_or_procedureContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitFunction_or_procedure(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Function_or_procedure() (localctx IFunction_or_procedureContext) {
	localctx = NewFunction_or_procedureContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 432, PostgreSQLParserRULE_function_or_procedure)
	var _la int

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(4003)
		_la = p.GetTokenStream().LA(1)

		if !(_la == PostgreSQLParserFUNCTION || _la == PostgreSQLParserPROCEDURE) {
			p.GetErrorHandler().RecoverInline(p)
		} else {
			p.GetErrorHandler().ReportMatch(p)
			p.Consume()
		}
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// ITriggerfuncargsContext is an interface to support dynamic dispatch.
type ITriggerfuncargsContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	AllTriggerfuncarg() []ITriggerfuncargContext
	Triggerfuncarg(i int) ITriggerfuncargContext
	AllCOMMA() []antlr.TerminalNode
	COMMA(i int) antlr.TerminalNode

	// IsTriggerfuncargsContext differentiates from other interfaces.
	IsTriggerfuncargsContext()
}

type TriggerfuncargsContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyTriggerfuncargsContext() *TriggerfuncargsContext {
	var p = new(TriggerfuncargsContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_triggerfuncargs
	return p
}

func InitEmptyTriggerfuncargsContext(p *TriggerfuncargsContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_triggerfuncargs
}

func (*TriggerfuncargsContext) IsTriggerfuncargsContext() {}

func NewTriggerfuncargsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TriggerfuncargsContext {
	var p = new(TriggerfuncargsContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_triggerfuncargs

	return p
}

func (s *TriggerfuncargsContext) GetParser() antlr.Parser { return s.parser }

func (s *TriggerfuncargsContext) AllTriggerfuncarg() []ITriggerfuncargContext {
	children := s.GetChildren()
	len := 0
	for _, ctx := range children {
		if _, ok := ctx.(ITriggerfuncargContext); ok {
			len++
		}
	}

	tst := make([]ITriggerfuncargContext, len)
	i := 0
	for _, ctx := range children {
		if t, ok := ctx.(ITriggerfuncargContext); ok {
			tst[i] = t.(ITriggerfuncargContext)
			i++
		}
	}

	return tst
}

func (s *TriggerfuncargsContext) Triggerfuncarg(i int) ITriggerfuncargContext {
	var t antlr.RuleContext
	j := 0
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ITriggerfuncargContext); ok {
			if j == i {
				t = ctx.(antlr.RuleContext)
				break
			}
			j++
		}
	}

	if t == nil {
		return nil
	}

	return t.(ITriggerfuncargContext)
}

func (s *TriggerfuncargsContext) AllCOMMA() []antlr.TerminalNode {
	return s.GetTokens(PostgreSQLParserCOMMA)
}

func (s *TriggerfuncargsContext) COMMA(i int) antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCOMMA, i)
}

func (s *TriggerfuncargsContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *TriggerfuncargsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *TriggerfuncargsContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterTriggerfuncargs(s)
	}
}

func (s *TriggerfuncargsContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitTriggerfuncargs(s)
	}
}

func (s *TriggerfuncargsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitTriggerfuncargs(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Triggerfuncargs() (localctx ITriggerfuncargsContext) {
	localctx = NewTriggerfuncargsContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 434, PostgreSQLParserRULE_triggerfuncargs)
	var _la int

	p.EnterOuterAlt(localctx, 1)
	p.SetState(4007)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetTokenStream().LA(1) {
	case PostgreSQLParserALL, PostgreSQLParserANALYSE, PostgreSQLParserANALYZE, PostgreSQLParserAND, PostgreSQLParserANY, PostgreSQLParserARRAY, PostgreSQLParserAS, PostgreSQLParserASC, PostgreSQLParserASYMMETRIC, PostgreSQLParserBOTH, PostgreSQLParserCASE, PostgreSQLParserCAST, PostgreSQLParserCHECK, PostgreSQLParserCOLLATE, PostgreSQLParserCOLUMN, PostgreSQLParserCONSTRAINT, PostgreSQLParserCREATE, PostgreSQLParserCURRENT_CATALOG, PostgreSQLParserCURRENT_DATE, PostgreSQLParserCURRENT_ROLE, PostgreSQLParserCURRENT_TIME, PostgreSQLParserCURRENT_TIMESTAMP, PostgreSQLParserCURRENT_USER, PostgreSQLParserDEFAULT, PostgreSQLParserDEFERRABLE, PostgreSQLParserDESC, PostgreSQLParserDISTINCT, PostgreSQLParserDO, PostgreSQLParserELSE, PostgreSQLParserEXCEPT, PostgreSQLParserFALSE_P, PostgreSQLParserFETCH, PostgreSQLParserFOR, PostgreSQLParserFOREIGN, PostgreSQLParserFROM, PostgreSQLParserGRANT, PostgreSQLParserGROUP_P, PostgreSQLParserHAVING, PostgreSQLParserIN_P, PostgreSQLParserINITIALLY, PostgreSQLParserINTERSECT, PostgreSQLParserLATERAL_P, PostgreSQLParserLEADING, PostgreSQLParserLIMIT, PostgreSQLParserLOCALTIME, PostgreSQLParserLOCALTIMESTAMP, PostgreSQLParserNOT, PostgreSQLParserNULL_P, PostgreSQLParserOFFSET, PostgreSQLParserON, PostgreSQLParserONLY, PostgreSQLParserOR, PostgreSQLParserORDER, PostgreSQLParserPLACING, PostgreSQLParserPRIMARY, PostgreSQLParserREFERENCES, PostgreSQLParserRETURNING, PostgreSQLParserSELECT, PostgreSQLParserSESSION_USER, PostgreSQLParserSOME, PostgreSQLParserSYMMETRIC, PostgreSQLParserTABLE, PostgreSQLParserTHEN, PostgreSQLParserTO, PostgreSQLParserTRAILING, PostgreSQLParserTRUE_P, PostgreSQLParserUNION, PostgreSQLParserUNIQUE, PostgreSQLParserUSER, PostgreSQLParserUSING, PostgreSQLParserVARIADIC, PostgreSQLParserWHEN, PostgreSQLParserWHERE, PostgreSQLParserWINDOW, PostgreSQLParserWITH, PostgreSQLParserAUTHORIZATION, PostgreSQLParserBINARY, PostgreSQLParserCOLLATION, PostgreSQLParserCONCURRENTLY, PostgreSQLParserCROSS, PostgreSQLParserCURRENT_SCHEMA, PostgreSQLParserFREEZE, PostgreSQLParserFULL, PostgreSQLParserILIKE, PostgreSQLParserINNER_P, PostgreSQLParserIS, PostgreSQLParserISNULL, PostgreSQLParserJOIN, PostgreSQLParserLIKE, PostgreSQLParserNATURAL, PostgreSQLParserNOTNULL, PostgreSQLParserOUTER_P, PostgreSQLParserOVER, PostgreSQLParserOVERLAPS, PostgreSQLParserSIMILAR, PostgreSQLParserVERBOSE, PostgreSQLParserABORT_P, PostgreSQLParserABSOLUTE_P, PostgreSQLParserACCESS, PostgreSQLParserACTION, PostgreSQLParserADD_P, PostgreSQLParserADMIN, PostgreSQLParserAFTER, PostgreSQLParserAGGREGATE, PostgreSQLParserALSO, PostgreSQLParserALTER, PostgreSQLParserALWAYS, PostgreSQLParserASSERTION, PostgreSQLParserASSIGNMENT, PostgreSQLParserAT, PostgreSQLParserATTRIBUTE, PostgreSQLParserBACKWARD, PostgreSQLParserBEFORE, PostgreSQLParserBEGIN_P, PostgreSQLParserBY, PostgreSQLParserCACHE, PostgreSQLParserCALLED, PostgreSQLParserCASCADE, PostgreSQLParserCASCADED, PostgreSQLParserCATALOG, PostgreSQLParserCHAIN, PostgreSQLParserCHARACTERISTICS, PostgreSQLParserCHECKPOINT, PostgreSQLParserCLASS, PostgreSQLParserCLOSE, PostgreSQLParserCLUSTER, PostgreSQLParserCOMMENT, PostgreSQLParserCOMMENTS, PostgreSQLParserCOMMIT, PostgreSQLParserCOMMITTED, PostgreSQLParserCONFIGURATION, PostgreSQLParserCONNECTION, PostgreSQLParserCONSTRAINTS, PostgreSQLParserCONTENT_P, PostgreSQLParserCONTINUE_P, PostgreSQLParserCONVERSION_P, PostgreSQLParserCOPY, PostgreSQLParserCOST, PostgreSQLParserCSV, PostgreSQLParserCURSOR, PostgreSQLParserCYCLE, PostgreSQLParserDATA_P, PostgreSQLParserDATABASE, PostgreSQLParserDAY_P, PostgreSQLParserDEALLOCATE, PostgreSQLParserDECLARE, PostgreSQLParserDEFAULTS, PostgreSQLParserDEFERRED, PostgreSQLParserDEFINER, PostgreSQLParserDELETE_P, PostgreSQLParserDELIMITER, PostgreSQLParserDELIMITERS, PostgreSQLParserDICTIONARY, PostgreSQLParserDISABLE_P, PostgreSQLParserDISCARD, PostgreSQLParserDOCUMENT_P, PostgreSQLParserDOMAIN_P, PostgreSQLParserDOUBLE_P, PostgreSQLParserDROP, PostgreSQLParserEACH, PostgreSQLParserENABLE_P, PostgreSQLParserENCODING, PostgreSQLParserENCRYPTED, PostgreSQLParserENUM_P, PostgreSQLParserESCAPE, PostgreSQLParserEVENT, PostgreSQLParserEXCLUDE, PostgreSQLParserEXCLUDING, PostgreSQLParserEXCLUSIVE, PostgreSQLParserEXECUTE, PostgreSQLParserEXPLAIN, PostgreSQLParserEXTENSION, PostgreSQLParserEXTERNAL, PostgreSQLParserFAMILY, PostgreSQLParserFIRST_P, PostgreSQLParserFOLLOWING, PostgreSQLParserFORCE, PostgreSQLParserFORWARD, PostgreSQLParserFUNCTION, PostgreSQLParserFUNCTIONS, PostgreSQLParserGLOBAL, PostgreSQLParserGRANTED, PostgreSQLParserHANDLER, PostgreSQLParserHEADER_P, PostgreSQLParserHOLD, PostgreSQLParserHOUR_P, PostgreSQLParserIDENTITY_P, PostgreSQLParserIF_P, PostgreSQLParserIMMEDIATE, PostgreSQLParserIMMUTABLE, PostgreSQLParserIMPLICIT_P, PostgreSQLParserINCLUDING, PostgreSQLParserINCREMENT, PostgreSQLParserINDEX, PostgreSQLParserINDEXES, PostgreSQLParserINHERIT, PostgreSQLParserINHERITS, PostgreSQLParserINLINE_P, PostgreSQLParserINSENSITIVE, PostgreSQLParserINSERT, PostgreSQLParserINSTEAD, PostgreSQLParserINVOKER, PostgreSQLParserISOLATION, PostgreSQLParserKEY, PostgreSQLParserLABEL, PostgreSQLParserLANGUAGE, PostgreSQLParserLARGE_P, PostgreSQLParserLAST_P, PostgreSQLParserLEAKPROOF, PostgreSQLParserLEVEL, PostgreSQLParserLISTEN, PostgreSQLParserLOAD, PostgreSQLParserLOCAL, PostgreSQLParserLOCATION, PostgreSQLParserLOCK_P, PostgreSQLParserMAPPING, PostgreSQLParserMATCH, PostgreSQLParserMATERIALIZED, PostgreSQLParserMAXVALUE, PostgreSQLParserMINUTE_P, PostgreSQLParserMINVALUE, PostgreSQLParserMODE, PostgreSQLParserMONTH_P, PostgreSQLParserMOVE, PostgreSQLParserNAME_P, PostgreSQLParserNAMES, PostgreSQLParserNEXT, PostgreSQLParserNO, PostgreSQLParserNOTHING, PostgreSQLParserNOTIFY, PostgreSQLParserNOWAIT, PostgreSQLParserNULLS_P, PostgreSQLParserOBJECT_P, PostgreSQLParserOF, PostgreSQLParserOFF, PostgreSQLParserOIDS, PostgreSQLParserOPERATOR, PostgreSQLParserOPTION, PostgreSQLParserOPTIONS, PostgreSQLParserOWNED, PostgreSQLParserOWNER, PostgreSQLParserPARSER, PostgreSQLParserPARTIAL, PostgreSQLParserPARTITION, PostgreSQLParserPASSING, PostgreSQLParserPASSWORD, PostgreSQLParserPLANS, PostgreSQLParserPRECEDING, PostgreSQLParserPREPARE, PostgreSQLParserPREPARED, PostgreSQLParserPRESERVE, PostgreSQLParserPRIOR, PostgreSQLParserPRIVILEGES, PostgreSQLParserPROCEDURAL, PostgreSQLParserPROCEDURE, PostgreSQLParserPROGRAM, PostgreSQLParserQUOTE, PostgreSQLParserRANGE, PostgreSQLParserREAD, PostgreSQLParserREASSIGN, PostgreSQLParserRECHECK, PostgreSQLParserRECURSIVE, PostgreSQLParserREF, PostgreSQLParserREFRESH, PostgreSQLParserREINDEX, PostgreSQLParserRELATIVE_P, PostgreSQLParserRELEASE, PostgreSQLParserRENAME, PostgreSQLParserREPEATABLE, PostgreSQLParserREPLACE, PostgreSQLParserREPLICA, PostgreSQLParserRESET, PostgreSQLParserRESTART, PostgreSQLParserRESTRICT, PostgreSQLParserRETURNS, PostgreSQLParserREVOKE, PostgreSQLParserROLE, PostgreSQLParserROLLBACK, PostgreSQLParserROWS, PostgreSQLParserRULE, PostgreSQLParserSAVEPOINT, PostgreSQLParserSCHEMA, PostgreSQLParserSCROLL, PostgreSQLParserSEARCH, PostgreSQLParserSECOND_P, PostgreSQLParserSECURITY, PostgreSQLParserSEQUENCE, PostgreSQLParserSEQUENCES, PostgreSQLParserSERIALIZABLE, PostgreSQLParserSERVER, PostgreSQLParserSESSION, PostgreSQLParserSET, PostgreSQLParserSHARE, PostgreSQLParserSHOW, PostgreSQLParserSIMPLE, PostgreSQLParserSNAPSHOT, PostgreSQLParserSTABLE, PostgreSQLParserSTANDALONE_P, PostgreSQLParserSTART, PostgreSQLParserSTATEMENT, PostgreSQLParserSTATISTICS, PostgreSQLParserSTDIN, PostgreSQLParserSTDOUT, PostgreSQLParserSTORAGE, PostgreSQLParserSTRICT_P, PostgreSQLParserSTRIP_P, PostgreSQLParserSYSID, PostgreSQLParserSYSTEM_P, PostgreSQLParserTABLES, PostgreSQLParserTABLESPACE, PostgreSQLParserTEMP, PostgreSQLParserTEMPLATE, PostgreSQLParserTEMPORARY, PostgreSQLParserTEXT_P, PostgreSQLParserTRANSACTION, PostgreSQLParserTRIGGER, PostgreSQLParserTRUNCATE, PostgreSQLParserTRUSTED, PostgreSQLParserTYPE_P, PostgreSQLParserTYPES_P, PostgreSQLParserUNBOUNDED, PostgreSQLParserUNCOMMITTED, PostgreSQLParserUNENCRYPTED, PostgreSQLParserUNKNOWN, PostgreSQLParserUNLISTEN, PostgreSQLParserUNLOGGED, PostgreSQLParserUNTIL, PostgreSQLParserUPDATE, PostgreSQLParserVACUUM, PostgreSQLParserVALID, PostgreSQLParserVALIDATE, PostgreSQLParserVALIDATOR, PostgreSQLParserVARYING, PostgreSQLParserVERSION_P, PostgreSQLParserVIEW, PostgreSQLParserVOLATILE, PostgreSQLParserWHITESPACE_P, PostgreSQLParserWITHOUT, PostgreSQLParserWORK, PostgreSQLParserWRAPPER, PostgreSQLParserWRITE, PostgreSQLParserXML_P, PostgreSQLParserYEAR_P, PostgreSQLParserYES_P, PostgreSQLParserZONE, PostgreSQLParserBETWEEN, PostgreSQLParserBIGINT, PostgreSQLParserBIT, PostgreSQLParserBOOLEAN_P, PostgreSQLParserCHAR_P, PostgreSQLParserCHARACTER, PostgreSQLParserCOALESCE, PostgreSQLParserDEC, PostgreSQLParserDECIMAL_P, PostgreSQLParserEXISTS, PostgreSQLParserEXTRACT, PostgreSQLParserFLOAT_P, PostgreSQLParserGREATEST, PostgreSQLParserINOUT, PostgreSQLParserINT_P, PostgreSQLParserINTEGER, PostgreSQLParserINTERVAL, PostgreSQLParserLEAST, PostgreSQLParserNATIONAL, PostgreSQLParserNCHAR, PostgreSQLParserNONE, PostgreSQLParserNULLIF, PostgreSQLParserNUMERIC, PostgreSQLParserOVERLAY, PostgreSQLParserPOSITION, PostgreSQLParserPRECISION, PostgreSQLParserREAL, PostgreSQLParserROW, PostgreSQLParserSETOF, PostgreSQLParserSMALLINT, PostgreSQLParserSUBSTRING, PostgreSQLParserTIME, PostgreSQLParserTIMESTAMP, PostgreSQLParserTREAT, PostgreSQLParserTRIM, PostgreSQLParserVALUES, PostgreSQLParserVARCHAR, PostgreSQLParserXMLATTRIBUTES, PostgreSQLParserXMLCOMMENT, PostgreSQLParserXMLAGG, PostgreSQLParserXML_IS_WELL_FORMED, PostgreSQLParserXML_IS_WELL_FORMED_DOCUMENT, PostgreSQLParserXML_IS_WELL_FORMED_CONTENT, PostgreSQLParserXPATH, PostgreSQLParserXPATH_EXISTS, PostgreSQLParserXMLCONCAT, PostgreSQLParserXMLELEMENT, PostgreSQLParserXMLEXISTS, PostgreSQLParserXMLFOREST, PostgreSQLParserXMLPARSE, PostgreSQLParserXMLPI, PostgreSQLParserXMLROOT, PostgreSQLParserXMLSERIALIZE, PostgreSQLParserCALL, PostgreSQLParserCURRENT_P, PostgreSQLParserATTACH, PostgreSQLParserDETACH, PostgreSQLParserEXPRESSION, PostgreSQLParserGENERATED, PostgreSQLParserLOGGED, PostgreSQLParserSTORED, PostgreSQLParserINCLUDE, PostgreSQLParserROUTINE, PostgreSQLParserTRANSFORM, PostgreSQLParserIMPORT_P, PostgreSQLParserPOLICY, PostgreSQLParserMETHOD, PostgreSQLParserREFERENCING, PostgreSQLParserNEW, PostgreSQLParserOLD, PostgreSQLParserVALUE_P, PostgreSQLParserSUBSCRIPTION, PostgreSQLParserPUBLICATION, PostgreSQLParserOUT_P, PostgreSQLParserEND_P, PostgreSQLParserROUTINES, PostgreSQLParserSCHEMAS, PostgreSQLParserPROCEDURES, PostgreSQLParserINPUT_P, PostgreSQLParserSUPPORT, PostgreSQLParserPARALLEL, PostgreSQLParserSQL_P, PostgreSQLParserDEPENDS, PostgreSQLParserOVERRIDING, PostgreSQLParserCONFLICT, PostgreSQLParserSKIP_P, PostgreSQLParserLOCKED, PostgreSQLParserTIES, PostgreSQLParserROLLUP, PostgreSQLParserCUBE, PostgreSQLParserGROUPING, PostgreSQLParserSETS, PostgreSQLParserTABLESAMPLE, PostgreSQLParserORDINALITY, PostgreSQLParserXMLTABLE, PostgreSQLParserCOLUMNS, PostgreSQLParserXMLNAMESPACES, PostgreSQLParserROWTYPE, PostgreSQLParserNORMALIZED, PostgreSQLParserWITHIN, PostgreSQLParserFILTER, PostgreSQLParserGROUPS, PostgreSQLParserOTHERS, PostgreSQLParserNFC, PostgreSQLParserNFD, PostgreSQLParserNFKC, PostgreSQLParserNFKD, PostgreSQLParserUESCAPE, PostgreSQLParserVIEWS, PostgreSQLParserNORMALIZE, PostgreSQLParserDUMP, PostgreSQLParserPRINT_STRICT_PARAMS, PostgreSQLParserVARIABLE_CONFLICT, PostgreSQLParserERROR, PostgreSQLParserUSE_VARIABLE, PostgreSQLParserUSE_COLUMN, PostgreSQLParserALIAS, PostgreSQLParserCONSTANT, PostgreSQLParserPERFORM, PostgreSQLParserGET, PostgreSQLParserDIAGNOSTICS, PostgreSQLParserSTACKED, PostgreSQLParserELSIF, PostgreSQLParserREVERSE, PostgreSQLParserSLICE, PostgreSQLParserEXIT, PostgreSQLParserRETURN, PostgreSQLParserQUERY, PostgreSQLParserRAISE, PostgreSQLParserSQLSTATE, PostgreSQLParserDEBUG, PostgreSQLParserLOG, PostgreSQLParserINFO, PostgreSQLParserNOTICE, PostgreSQLParserWARNING, PostgreSQLParserEXCEPTION, PostgreSQLParserASSERT, PostgreSQLParserOPEN, PostgreSQLParserABS, PostgreSQLParserCBRT, PostgreSQLParserCEIL, PostgreSQLParserCEILING, PostgreSQLParserDEGREES, PostgreSQLParserDIV, PostgreSQLParserEXP, PostgreSQLParserFACTORIAL, PostgreSQLParserFLOOR, PostgreSQLParserGCD, PostgreSQLParserLCM, PostgreSQLParserLN, PostgreSQLParserLOG10, PostgreSQLParserMIN_SCALE, PostgreSQLParserMOD, PostgreSQLParserPI, PostgreSQLParserPOWER, PostgreSQLParserRADIANS, PostgreSQLParserROUND, PostgreSQLParserSCALE, PostgreSQLParserSIGN, PostgreSQLParserSQRT, PostgreSQLParserTRIM_SCALE, PostgreSQLParserTRUNC, PostgreSQLParserWIDTH_BUCKET, PostgreSQLParserRANDOM, PostgreSQLParserSETSEED, PostgreSQLParserACOS, PostgreSQLParserACOSD, PostgreSQLParserASIN, PostgreSQLParserASIND, PostgreSQLParserATAN, PostgreSQLParserATAND, PostgreSQLParserATAN2, PostgreSQLParserATAN2D, PostgreSQLParserCOS, PostgreSQLParserCOSD, PostgreSQLParserCOT, PostgreSQLParserCOTD, PostgreSQLParserSIN, PostgreSQLParserSIND, PostgreSQLParserTAN, PostgreSQLParserTAND, PostgreSQLParserSINH, PostgreSQLParserCOSH, PostgreSQLParserTANH, PostgreSQLParserASINH, PostgreSQLParserACOSH, PostgreSQLParserATANH, PostgreSQLParserBIT_LENGTH, PostgreSQLParserCHAR_LENGTH, PostgreSQLParserCHARACTER_LENGTH, PostgreSQLParserLOWER, PostgreSQLParserOCTET_LENGTH, PostgreSQLParserUPPER, PostgreSQLParserASCII, PostgreSQLParserBTRIM, PostgreSQLParserCHR, PostgreSQLParserCONCAT, PostgreSQLParserCONCAT_WS, PostgreSQLParserFORMAT, PostgreSQLParserINITCAP, PostgreSQLParserLENGTH, PostgreSQLParserLPAD, PostgreSQLParserLTRIM, PostgreSQLParserMD5, PostgreSQLParserPARSE_IDENT, PostgreSQLParserPG_CLIENT_ENCODING, PostgreSQLParserQUOTE_IDENT, PostgreSQLParserQUOTE_LITERAL, PostgreSQLParserQUOTE_NULLABLE, PostgreSQLParserREGEXP_COUNT, PostgreSQLParserREGEXP_INSTR, PostgreSQLParserREGEXP_LIKE, PostgreSQLParserREGEXP_MATCH, PostgreSQLParserREGEXP_MATCHES, PostgreSQLParserREGEXP_REPLACE, PostgreSQLParserREGEXP_SPLIT_TO_ARRAY, PostgreSQLParserREGEXP_SPLIT_TO_TABLE, PostgreSQLParserREGEXP_SUBSTR, PostgreSQLParserREPEAT, PostgreSQLParserRPAD, PostgreSQLParserRTRIM, PostgreSQLParserSPLIT_PART, PostgreSQLParserSTARTS_WITH, PostgreSQLParserSTRING_TO_ARRAY, PostgreSQLParserSTRING_TO_TABLE, PostgreSQLParserSTRPOS, PostgreSQLParserSUBSTR, PostgreSQLParserTO_ASCII, PostgreSQLParserTO_HEX, PostgreSQLParserTRANSLATE, PostgreSQLParserUNISTR, PostgreSQLParserAGE, PostgreSQLParserCLOCK_TIMESTAMP, PostgreSQLParserDATE_BIN, PostgreSQLParserDATE_PART, PostgreSQLParserDATE_TRUNC, PostgreSQLParserISFINITE, PostgreSQLParserJUSTIFY_DAYS, PostgreSQLParserJUSTIFY_HOURS, PostgreSQLParserJUSTIFY_INTERVAL, PostgreSQLParserMAKE_DATE, PostgreSQLParserMAKE_INTERVAL, PostgreSQLParserMAKE_TIME, PostgreSQLParserMAKE_TIMESTAMP, PostgreSQLParserMAKE_TIMESTAMPTZ, PostgreSQLParserNOW, PostgreSQLParserSTATEMENT_TIMESTAMP, PostgreSQLParserTIMEOFDAY, PostgreSQLParserTRANSACTION_TIMESTAMP, PostgreSQLParserTO_TIMESTAMP, PostgreSQLParserTO_CHAR, PostgreSQLParserTO_DATE, PostgreSQLParserTO_NUMBER, PostgreSQLParserIdentifier, PostgreSQLParserQuotedIdentifier, PostgreSQLParserUnicodeQuotedIdentifier, PostgreSQLParserStringConstant, PostgreSQLParserUnicodeEscapeStringConstant, PostgreSQLParserBeginDollarStringConstant, PostgreSQLParserIntegral, PostgreSQLParserNumeric, PostgreSQLParserPLSQLVARIABLENAME, PostgreSQLParserPLSQLIDENTIFIER, PostgreSQLParserEscapeStringConstant:
		{
			p.SetState(4005)
			p.Triggerfuncarg()
		}

	case PostgreSQLParserCLOSE_PAREN, PostgreSQLParserCOMMA:

	default:
		p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		goto errorExit
	}
	p.SetState(4013)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}
	_la = p.GetTokenStream().LA(1)

	for _la == PostgreSQLParserCOMMA {
		{
			p.SetState(4009)
			p.Match(PostgreSQLParserCOMMA)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4010)
			p.Triggerfuncarg()
		}

		p.SetState(4015)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}
		_la = p.GetTokenStream().LA(1)
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// ITriggerfuncargContext is an interface to support dynamic dispatch.
type ITriggerfuncargContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Iconst() IIconstContext
	Fconst() IFconstContext
	Sconst() ISconstContext
	Collabel() ICollabelContext

	// IsTriggerfuncargContext differentiates from other interfaces.
	IsTriggerfuncargContext()
}

type TriggerfuncargContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyTriggerfuncargContext() *TriggerfuncargContext {
	var p = new(TriggerfuncargContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_triggerfuncarg
	return p
}

func InitEmptyTriggerfuncargContext(p *TriggerfuncargContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_triggerfuncarg
}

func (*TriggerfuncargContext) IsTriggerfuncargContext() {}

func NewTriggerfuncargContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TriggerfuncargContext {
	var p = new(TriggerfuncargContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_triggerfuncarg

	return p
}

func (s *TriggerfuncargContext) GetParser() antlr.Parser { return s.parser }

func (s *TriggerfuncargContext) Iconst() IIconstContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IIconstContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IIconstContext)
}

func (s *TriggerfuncargContext) Fconst() IFconstContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IFconstContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IFconstContext)
}

func (s *TriggerfuncargContext) Sconst() ISconstContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ISconstContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ISconstContext)
}

func (s *TriggerfuncargContext) Collabel() ICollabelContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ICollabelContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ICollabelContext)
}

func (s *TriggerfuncargContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *TriggerfuncargContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *TriggerfuncargContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterTriggerfuncarg(s)
	}
}

func (s *TriggerfuncargContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitTriggerfuncarg(s)
	}
}

func (s *TriggerfuncargContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitTriggerfuncarg(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Triggerfuncarg() (localctx ITriggerfuncargContext) {
	localctx = NewTriggerfuncargContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 436, PostgreSQLParserRULE_triggerfuncarg)
	p.SetState(4020)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetTokenStream().LA(1) {
	case PostgreSQLParserIntegral:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(4016)
			p.Iconst()
		}

	case PostgreSQLParserNumeric:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(4017)
			p.Fconst()
		}

	case PostgreSQLParserStringConstant, PostgreSQLParserUnicodeEscapeStringConstant, PostgreSQLParserBeginDollarStringConstant, PostgreSQLParserEscapeStringConstant:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(4018)
			p.Sconst()
		}

	case PostgreSQLParserALL, PostgreSQLParserANALYSE, PostgreSQLParserANALYZE, PostgreSQLParserAND, PostgreSQLParserANY, PostgreSQLParserARRAY, PostgreSQLParserAS, PostgreSQLParserASC, PostgreSQLParserASYMMETRIC, PostgreSQLParserBOTH, PostgreSQLParserCASE, PostgreSQLParserCAST, PostgreSQLParserCHECK, PostgreSQLParserCOLLATE, PostgreSQLParserCOLUMN, PostgreSQLParserCONSTRAINT, PostgreSQLParserCREATE, PostgreSQLParserCURRENT_CATALOG, PostgreSQLParserCURRENT_DATE, PostgreSQLParserCURRENT_ROLE, PostgreSQLParserCURRENT_TIME, PostgreSQLParserCURRENT_TIMESTAMP, PostgreSQLParserCURRENT_USER, PostgreSQLParserDEFAULT, PostgreSQLParserDEFERRABLE, PostgreSQLParserDESC, PostgreSQLParserDISTINCT, PostgreSQLParserDO, PostgreSQLParserELSE, PostgreSQLParserEXCEPT, PostgreSQLParserFALSE_P, PostgreSQLParserFETCH, PostgreSQLParserFOR, PostgreSQLParserFOREIGN, PostgreSQLParserFROM, PostgreSQLParserGRANT, PostgreSQLParserGROUP_P, PostgreSQLParserHAVING, PostgreSQLParserIN_P, PostgreSQLParserINITIALLY, PostgreSQLParserINTERSECT, PostgreSQLParserLATERAL_P, PostgreSQLParserLEADING, PostgreSQLParserLIMIT, PostgreSQLParserLOCALTIME, PostgreSQLParserLOCALTIMESTAMP, PostgreSQLParserNOT, PostgreSQLParserNULL_P, PostgreSQLParserOFFSET, PostgreSQLParserON, PostgreSQLParserONLY, PostgreSQLParserOR, PostgreSQLParserORDER, PostgreSQLParserPLACING, PostgreSQLParserPRIMARY, PostgreSQLParserREFERENCES, PostgreSQLParserRETURNING, PostgreSQLParserSELECT, PostgreSQLParserSESSION_USER, PostgreSQLParserSOME, PostgreSQLParserSYMMETRIC, PostgreSQLParserTABLE, PostgreSQLParserTHEN, PostgreSQLParserTO, PostgreSQLParserTRAILING, PostgreSQLParserTRUE_P, PostgreSQLParserUNION, PostgreSQLParserUNIQUE, PostgreSQLParserUSER, PostgreSQLParserUSING, PostgreSQLParserVARIADIC, PostgreSQLParserWHEN, PostgreSQLParserWHERE, PostgreSQLParserWINDOW, PostgreSQLParserWITH, PostgreSQLParserAUTHORIZATION, PostgreSQLParserBINARY, PostgreSQLParserCOLLATION, PostgreSQLParserCONCURRENTLY, PostgreSQLParserCROSS, PostgreSQLParserCURRENT_SCHEMA, PostgreSQLParserFREEZE, PostgreSQLParserFULL, PostgreSQLParserILIKE, PostgreSQLParserINNER_P, PostgreSQLParserIS, PostgreSQLParserISNULL, PostgreSQLParserJOIN, PostgreSQLParserLIKE, PostgreSQLParserNATURAL, PostgreSQLParserNOTNULL, PostgreSQLParserOUTER_P, PostgreSQLParserOVER, PostgreSQLParserOVERLAPS, PostgreSQLParserSIMILAR, PostgreSQLParserVERBOSE, PostgreSQLParserABORT_P, PostgreSQLParserABSOLUTE_P, PostgreSQLParserACCESS, PostgreSQLParserACTION, PostgreSQLParserADD_P, PostgreSQLParserADMIN, PostgreSQLParserAFTER, PostgreSQLParserAGGREGATE, PostgreSQLParserALSO, PostgreSQLParserALTER, PostgreSQLParserALWAYS, PostgreSQLParserASSERTION, PostgreSQLParserASSIGNMENT, PostgreSQLParserAT, PostgreSQLParserATTRIBUTE, PostgreSQLParserBACKWARD, PostgreSQLParserBEFORE, PostgreSQLParserBEGIN_P, PostgreSQLParserBY, PostgreSQLParserCACHE, PostgreSQLParserCALLED, PostgreSQLParserCASCADE, PostgreSQLParserCASCADED, PostgreSQLParserCATALOG, PostgreSQLParserCHAIN, PostgreSQLParserCHARACTERISTICS, PostgreSQLParserCHECKPOINT, PostgreSQLParserCLASS, PostgreSQLParserCLOSE, PostgreSQLParserCLUSTER, PostgreSQLParserCOMMENT, PostgreSQLParserCOMMENTS, PostgreSQLParserCOMMIT, PostgreSQLParserCOMMITTED, PostgreSQLParserCONFIGURATION, PostgreSQLParserCONNECTION, PostgreSQLParserCONSTRAINTS, PostgreSQLParserCONTENT_P, PostgreSQLParserCONTINUE_P, PostgreSQLParserCONVERSION_P, PostgreSQLParserCOPY, PostgreSQLParserCOST, PostgreSQLParserCSV, PostgreSQLParserCURSOR, PostgreSQLParserCYCLE, PostgreSQLParserDATA_P, PostgreSQLParserDATABASE, PostgreSQLParserDAY_P, PostgreSQLParserDEALLOCATE, PostgreSQLParserDECLARE, PostgreSQLParserDEFAULTS, PostgreSQLParserDEFERRED, PostgreSQLParserDEFINER, PostgreSQLParserDELETE_P, PostgreSQLParserDELIMITER, PostgreSQLParserDELIMITERS, PostgreSQLParserDICTIONARY, PostgreSQLParserDISABLE_P, PostgreSQLParserDISCARD, PostgreSQLParserDOCUMENT_P, PostgreSQLParserDOMAIN_P, PostgreSQLParserDOUBLE_P, PostgreSQLParserDROP, PostgreSQLParserEACH, PostgreSQLParserENABLE_P, PostgreSQLParserENCODING, PostgreSQLParserENCRYPTED, PostgreSQLParserENUM_P, PostgreSQLParserESCAPE, PostgreSQLParserEVENT, PostgreSQLParserEXCLUDE, PostgreSQLParserEXCLUDING, PostgreSQLParserEXCLUSIVE, PostgreSQLParserEXECUTE, PostgreSQLParserEXPLAIN, PostgreSQLParserEXTENSION, PostgreSQLParserEXTERNAL, PostgreSQLParserFAMILY, PostgreSQLParserFIRST_P, PostgreSQLParserFOLLOWING, PostgreSQLParserFORCE, PostgreSQLParserFORWARD, PostgreSQLParserFUNCTION, PostgreSQLParserFUNCTIONS, PostgreSQLParserGLOBAL, PostgreSQLParserGRANTED, PostgreSQLParserHANDLER, PostgreSQLParserHEADER_P, PostgreSQLParserHOLD, PostgreSQLParserHOUR_P, PostgreSQLParserIDENTITY_P, PostgreSQLParserIF_P, PostgreSQLParserIMMEDIATE, PostgreSQLParserIMMUTABLE, PostgreSQLParserIMPLICIT_P, PostgreSQLParserINCLUDING, PostgreSQLParserINCREMENT, PostgreSQLParserINDEX, PostgreSQLParserINDEXES, PostgreSQLParserINHERIT, PostgreSQLParserINHERITS, PostgreSQLParserINLINE_P, PostgreSQLParserINSENSITIVE, PostgreSQLParserINSERT, PostgreSQLParserINSTEAD, PostgreSQLParserINVOKER, PostgreSQLParserISOLATION, PostgreSQLParserKEY, PostgreSQLParserLABEL, PostgreSQLParserLANGUAGE, PostgreSQLParserLARGE_P, PostgreSQLParserLAST_P, PostgreSQLParserLEAKPROOF, PostgreSQLParserLEVEL, PostgreSQLParserLISTEN, PostgreSQLParserLOAD, PostgreSQLParserLOCAL, PostgreSQLParserLOCATION, PostgreSQLParserLOCK_P, PostgreSQLParserMAPPING, PostgreSQLParserMATCH, PostgreSQLParserMATERIALIZED, PostgreSQLParserMAXVALUE, PostgreSQLParserMINUTE_P, PostgreSQLParserMINVALUE, PostgreSQLParserMODE, PostgreSQLParserMONTH_P, PostgreSQLParserMOVE, PostgreSQLParserNAME_P, PostgreSQLParserNAMES, PostgreSQLParserNEXT, PostgreSQLParserNO, PostgreSQLParserNOTHING, PostgreSQLParserNOTIFY, PostgreSQLParserNOWAIT, PostgreSQLParserNULLS_P, PostgreSQLParserOBJECT_P, PostgreSQLParserOF, PostgreSQLParserOFF, PostgreSQLParserOIDS, PostgreSQLParserOPERATOR, PostgreSQLParserOPTION, PostgreSQLParserOPTIONS, PostgreSQLParserOWNED, PostgreSQLParserOWNER, PostgreSQLParserPARSER, PostgreSQLParserPARTIAL, PostgreSQLParserPARTITION, PostgreSQLParserPASSING, PostgreSQLParserPASSWORD, PostgreSQLParserPLANS, PostgreSQLParserPRECEDING, PostgreSQLParserPREPARE, PostgreSQLParserPREPARED, PostgreSQLParserPRESERVE, PostgreSQLParserPRIOR, PostgreSQLParserPRIVILEGES, PostgreSQLParserPROCEDURAL, PostgreSQLParserPROCEDURE, PostgreSQLParserPROGRAM, PostgreSQLParserQUOTE, PostgreSQLParserRANGE, PostgreSQLParserREAD, PostgreSQLParserREASSIGN, PostgreSQLParserRECHECK, PostgreSQLParserRECURSIVE, PostgreSQLParserREF, PostgreSQLParserREFRESH, PostgreSQLParserREINDEX, PostgreSQLParserRELATIVE_P, PostgreSQLParserRELEASE, PostgreSQLParserRENAME, PostgreSQLParserREPEATABLE, PostgreSQLParserREPLACE, PostgreSQLParserREPLICA, PostgreSQLParserRESET, PostgreSQLParserRESTART, PostgreSQLParserRESTRICT, PostgreSQLParserRETURNS, PostgreSQLParserREVOKE, PostgreSQLParserROLE, PostgreSQLParserROLLBACK, PostgreSQLParserROWS, PostgreSQLParserRULE, PostgreSQLParserSAVEPOINT, PostgreSQLParserSCHEMA, PostgreSQLParserSCROLL, PostgreSQLParserSEARCH, PostgreSQLParserSECOND_P, PostgreSQLParserSECURITY, PostgreSQLParserSEQUENCE, PostgreSQLParserSEQUENCES, PostgreSQLParserSERIALIZABLE, PostgreSQLParserSERVER, PostgreSQLParserSESSION, PostgreSQLParserSET, PostgreSQLParserSHARE, PostgreSQLParserSHOW, PostgreSQLParserSIMPLE, PostgreSQLParserSNAPSHOT, PostgreSQLParserSTABLE, PostgreSQLParserSTANDALONE_P, PostgreSQLParserSTART, PostgreSQLParserSTATEMENT, PostgreSQLParserSTATISTICS, PostgreSQLParserSTDIN, PostgreSQLParserSTDOUT, PostgreSQLParserSTORAGE, PostgreSQLParserSTRICT_P, PostgreSQLParserSTRIP_P, PostgreSQLParserSYSID, PostgreSQLParserSYSTEM_P, PostgreSQLParserTABLES, PostgreSQLParserTABLESPACE, PostgreSQLParserTEMP, PostgreSQLParserTEMPLATE, PostgreSQLParserTEMPORARY, PostgreSQLParserTEXT_P, PostgreSQLParserTRANSACTION, PostgreSQLParserTRIGGER, PostgreSQLParserTRUNCATE, PostgreSQLParserTRUSTED, PostgreSQLParserTYPE_P, PostgreSQLParserTYPES_P, PostgreSQLParserUNBOUNDED, PostgreSQLParserUNCOMMITTED, PostgreSQLParserUNENCRYPTED, PostgreSQLParserUNKNOWN, PostgreSQLParserUNLISTEN, PostgreSQLParserUNLOGGED, PostgreSQLParserUNTIL, PostgreSQLParserUPDATE, PostgreSQLParserVACUUM, PostgreSQLParserVALID, PostgreSQLParserVALIDATE, PostgreSQLParserVALIDATOR, PostgreSQLParserVARYING, PostgreSQLParserVERSION_P, PostgreSQLParserVIEW, PostgreSQLParserVOLATILE, PostgreSQLParserWHITESPACE_P, PostgreSQLParserWITHOUT, PostgreSQLParserWORK, PostgreSQLParserWRAPPER, PostgreSQLParserWRITE, PostgreSQLParserXML_P, PostgreSQLParserYEAR_P, PostgreSQLParserYES_P, PostgreSQLParserZONE, PostgreSQLParserBETWEEN, PostgreSQLParserBIGINT, PostgreSQLParserBIT, PostgreSQLParserBOOLEAN_P, PostgreSQLParserCHAR_P, PostgreSQLParserCHARACTER, PostgreSQLParserCOALESCE, PostgreSQLParserDEC, PostgreSQLParserDECIMAL_P, PostgreSQLParserEXISTS, PostgreSQLParserEXTRACT, PostgreSQLParserFLOAT_P, PostgreSQLParserGREATEST, PostgreSQLParserINOUT, PostgreSQLParserINT_P, PostgreSQLParserINTEGER, PostgreSQLParserINTERVAL, PostgreSQLParserLEAST, PostgreSQLParserNATIONAL, PostgreSQLParserNCHAR, PostgreSQLParserNONE, PostgreSQLParserNULLIF, PostgreSQLParserNUMERIC, PostgreSQLParserOVERLAY, PostgreSQLParserPOSITION, PostgreSQLParserPRECISION, PostgreSQLParserREAL, PostgreSQLParserROW, PostgreSQLParserSETOF, PostgreSQLParserSMALLINT, PostgreSQLParserSUBSTRING, PostgreSQLParserTIME, PostgreSQLParserTIMESTAMP, PostgreSQLParserTREAT, PostgreSQLParserTRIM, PostgreSQLParserVALUES, PostgreSQLParserVARCHAR, PostgreSQLParserXMLATTRIBUTES, PostgreSQLParserXMLCOMMENT, PostgreSQLParserXMLAGG, PostgreSQLParserXML_IS_WELL_FORMED, PostgreSQLParserXML_IS_WELL_FORMED_DOCUMENT, PostgreSQLParserXML_IS_WELL_FORMED_CONTENT, PostgreSQLParserXPATH, PostgreSQLParserXPATH_EXISTS, PostgreSQLParserXMLCONCAT, PostgreSQLParserXMLELEMENT, PostgreSQLParserXMLEXISTS, PostgreSQLParserXMLFOREST, PostgreSQLParserXMLPARSE, PostgreSQLParserXMLPI, PostgreSQLParserXMLROOT, PostgreSQLParserXMLSERIALIZE, PostgreSQLParserCALL, PostgreSQLParserCURRENT_P, PostgreSQLParserATTACH, PostgreSQLParserDETACH, PostgreSQLParserEXPRESSION, PostgreSQLParserGENERATED, PostgreSQLParserLOGGED, PostgreSQLParserSTORED, PostgreSQLParserINCLUDE, PostgreSQLParserROUTINE, PostgreSQLParserTRANSFORM, PostgreSQLParserIMPORT_P, PostgreSQLParserPOLICY, PostgreSQLParserMETHOD, PostgreSQLParserREFERENCING, PostgreSQLParserNEW, PostgreSQLParserOLD, PostgreSQLParserVALUE_P, PostgreSQLParserSUBSCRIPTION, PostgreSQLParserPUBLICATION, PostgreSQLParserOUT_P, PostgreSQLParserEND_P, PostgreSQLParserROUTINES, PostgreSQLParserSCHEMAS, PostgreSQLParserPROCEDURES, PostgreSQLParserINPUT_P, PostgreSQLParserSUPPORT, PostgreSQLParserPARALLEL, PostgreSQLParserSQL_P, PostgreSQLParserDEPENDS, PostgreSQLParserOVERRIDING, PostgreSQLParserCONFLICT, PostgreSQLParserSKIP_P, PostgreSQLParserLOCKED, PostgreSQLParserTIES, PostgreSQLParserROLLUP, PostgreSQLParserCUBE, PostgreSQLParserGROUPING, PostgreSQLParserSETS, PostgreSQLParserTABLESAMPLE, PostgreSQLParserORDINALITY, PostgreSQLParserXMLTABLE, PostgreSQLParserCOLUMNS, PostgreSQLParserXMLNAMESPACES, PostgreSQLParserROWTYPE, PostgreSQLParserNORMALIZED, PostgreSQLParserWITHIN, PostgreSQLParserFILTER, PostgreSQLParserGROUPS, PostgreSQLParserOTHERS, PostgreSQLParserNFC, PostgreSQLParserNFD, PostgreSQLParserNFKC, PostgreSQLParserNFKD, PostgreSQLParserUESCAPE, PostgreSQLParserVIEWS, PostgreSQLParserNORMALIZE, PostgreSQLParserDUMP, PostgreSQLParserPRINT_STRICT_PARAMS, PostgreSQLParserVARIABLE_CONFLICT, PostgreSQLParserERROR, PostgreSQLParserUSE_VARIABLE, PostgreSQLParserUSE_COLUMN, PostgreSQLParserALIAS, PostgreSQLParserCONSTANT, PostgreSQLParserPERFORM, PostgreSQLParserGET, PostgreSQLParserDIAGNOSTICS, PostgreSQLParserSTACKED, PostgreSQLParserELSIF, PostgreSQLParserREVERSE, PostgreSQLParserSLICE, PostgreSQLParserEXIT, PostgreSQLParserRETURN, PostgreSQLParserQUERY, PostgreSQLParserRAISE, PostgreSQLParserSQLSTATE, PostgreSQLParserDEBUG, PostgreSQLParserLOG, PostgreSQLParserINFO, PostgreSQLParserNOTICE, PostgreSQLParserWARNING, PostgreSQLParserEXCEPTION, PostgreSQLParserASSERT, PostgreSQLParserOPEN, PostgreSQLParserABS, PostgreSQLParserCBRT, PostgreSQLParserCEIL, PostgreSQLParserCEILING, PostgreSQLParserDEGREES, PostgreSQLParserDIV, PostgreSQLParserEXP, PostgreSQLParserFACTORIAL, PostgreSQLParserFLOOR, PostgreSQLParserGCD, PostgreSQLParserLCM, PostgreSQLParserLN, PostgreSQLParserLOG10, PostgreSQLParserMIN_SCALE, PostgreSQLParserMOD, PostgreSQLParserPI, PostgreSQLParserPOWER, PostgreSQLParserRADIANS, PostgreSQLParserROUND, PostgreSQLParserSCALE, PostgreSQLParserSIGN, PostgreSQLParserSQRT, PostgreSQLParserTRIM_SCALE, PostgreSQLParserTRUNC, PostgreSQLParserWIDTH_BUCKET, PostgreSQLParserRANDOM, PostgreSQLParserSETSEED, PostgreSQLParserACOS, PostgreSQLParserACOSD, PostgreSQLParserASIN, PostgreSQLParserASIND, PostgreSQLParserATAN, PostgreSQLParserATAND, PostgreSQLParserATAN2, PostgreSQLParserATAN2D, PostgreSQLParserCOS, PostgreSQLParserCOSD, PostgreSQLParserCOT, PostgreSQLParserCOTD, PostgreSQLParserSIN, PostgreSQLParserSIND, PostgreSQLParserTAN, PostgreSQLParserTAND, PostgreSQLParserSINH, PostgreSQLParserCOSH, PostgreSQLParserTANH, PostgreSQLParserASINH, PostgreSQLParserACOSH, PostgreSQLParserATANH, PostgreSQLParserBIT_LENGTH, PostgreSQLParserCHAR_LENGTH, PostgreSQLParserCHARACTER_LENGTH, PostgreSQLParserLOWER, PostgreSQLParserOCTET_LENGTH, PostgreSQLParserUPPER, PostgreSQLParserASCII, PostgreSQLParserBTRIM, PostgreSQLParserCHR, PostgreSQLParserCONCAT, PostgreSQLParserCONCAT_WS, PostgreSQLParserFORMAT, PostgreSQLParserINITCAP, PostgreSQLParserLENGTH, PostgreSQLParserLPAD, PostgreSQLParserLTRIM, PostgreSQLParserMD5, PostgreSQLParserPARSE_IDENT, PostgreSQLParserPG_CLIENT_ENCODING, PostgreSQLParserQUOTE_IDENT, PostgreSQLParserQUOTE_LITERAL, PostgreSQLParserQUOTE_NULLABLE, PostgreSQLParserREGEXP_COUNT, PostgreSQLParserREGEXP_INSTR, PostgreSQLParserREGEXP_LIKE, PostgreSQLParserREGEXP_MATCH, PostgreSQLParserREGEXP_MATCHES, PostgreSQLParserREGEXP_REPLACE, PostgreSQLParserREGEXP_SPLIT_TO_ARRAY, PostgreSQLParserREGEXP_SPLIT_TO_TABLE, PostgreSQLParserREGEXP_SUBSTR, PostgreSQLParserREPEAT, PostgreSQLParserRPAD, PostgreSQLParserRTRIM, PostgreSQLParserSPLIT_PART, PostgreSQLParserSTARTS_WITH, PostgreSQLParserSTRING_TO_ARRAY, PostgreSQLParserSTRING_TO_TABLE, PostgreSQLParserSTRPOS, PostgreSQLParserSUBSTR, PostgreSQLParserTO_ASCII, PostgreSQLParserTO_HEX, PostgreSQLParserTRANSLATE, PostgreSQLParserUNISTR, PostgreSQLParserAGE, PostgreSQLParserCLOCK_TIMESTAMP, PostgreSQLParserDATE_BIN, PostgreSQLParserDATE_PART, PostgreSQLParserDATE_TRUNC, PostgreSQLParserISFINITE, PostgreSQLParserJUSTIFY_DAYS, PostgreSQLParserJUSTIFY_HOURS, PostgreSQLParserJUSTIFY_INTERVAL, PostgreSQLParserMAKE_DATE, PostgreSQLParserMAKE_INTERVAL, PostgreSQLParserMAKE_TIME, PostgreSQLParserMAKE_TIMESTAMP, PostgreSQLParserMAKE_TIMESTAMPTZ, PostgreSQLParserNOW, PostgreSQLParserSTATEMENT_TIMESTAMP, PostgreSQLParserTIMEOFDAY, PostgreSQLParserTRANSACTION_TIMESTAMP, PostgreSQLParserTO_TIMESTAMP, PostgreSQLParserTO_CHAR, PostgreSQLParserTO_DATE, PostgreSQLParserTO_NUMBER, PostgreSQLParserIdentifier, PostgreSQLParserQuotedIdentifier, PostgreSQLParserUnicodeQuotedIdentifier, PostgreSQLParserPLSQLVARIABLENAME, PostgreSQLParserPLSQLIDENTIFIER:
		p.EnterOuterAlt(localctx, 4)
		{
			p.SetState(4019)
			p.Collabel()
		}

	default:
		p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IOptconstrfromtableContext is an interface to support dynamic dispatch.
type IOptconstrfromtableContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	FROM() antlr.TerminalNode
	Qualified_name() IQualified_nameContext

	// IsOptconstrfromtableContext differentiates from other interfaces.
	IsOptconstrfromtableContext()
}

type OptconstrfromtableContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyOptconstrfromtableContext() *OptconstrfromtableContext {
	var p = new(OptconstrfromtableContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_optconstrfromtable
	return p
}

func InitEmptyOptconstrfromtableContext(p *OptconstrfromtableContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_optconstrfromtable
}

func (*OptconstrfromtableContext) IsOptconstrfromtableContext() {}

func NewOptconstrfromtableContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *OptconstrfromtableContext {
	var p = new(OptconstrfromtableContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_optconstrfromtable

	return p
}

func (s *OptconstrfromtableContext) GetParser() antlr.Parser { return s.parser }

func (s *OptconstrfromtableContext) FROM() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserFROM, 0)
}

func (s *OptconstrfromtableContext) Qualified_name() IQualified_nameContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IQualified_nameContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IQualified_nameContext)
}

func (s *OptconstrfromtableContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *OptconstrfromtableContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *OptconstrfromtableContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterOptconstrfromtable(s)
	}
}

func (s *OptconstrfromtableContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitOptconstrfromtable(s)
	}
}

func (s *OptconstrfromtableContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitOptconstrfromtable(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Optconstrfromtable() (localctx IOptconstrfromtableContext) {
	localctx = NewOptconstrfromtableContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 438, PostgreSQLParserRULE_optconstrfromtable)
	p.SetState(4025)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetTokenStream().LA(1) {
	case PostgreSQLParserFROM:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(4022)
			p.Match(PostgreSQLParserFROM)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4023)
			p.Qualified_name()
		}

	case PostgreSQLParserDEFERRABLE, PostgreSQLParserFOR, PostgreSQLParserINITIALLY, PostgreSQLParserNOT, PostgreSQLParserNO:
		p.EnterOuterAlt(localctx, 2)

	default:
		p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IConstraintattributespecContext is an interface to support dynamic dispatch.
type IConstraintattributespecContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	AllConstraintattributeElem() []IConstraintattributeElemContext
	ConstraintattributeElem(i int) IConstraintattributeElemContext

	// IsConstraintattributespecContext differentiates from other interfaces.
	IsConstraintattributespecContext()
}

type ConstraintattributespecContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyConstraintattributespecContext() *ConstraintattributespecContext {
	var p = new(ConstraintattributespecContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_constraintattributespec
	return p
}

func InitEmptyConstraintattributespecContext(p *ConstraintattributespecContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_constraintattributespec
}

func (*ConstraintattributespecContext) IsConstraintattributespecContext() {}

func NewConstraintattributespecContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ConstraintattributespecContext {
	var p = new(ConstraintattributespecContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_constraintattributespec

	return p
}

func (s *ConstraintattributespecContext) GetParser() antlr.Parser { return s.parser }

func (s *ConstraintattributespecContext) AllConstraintattributeElem() []IConstraintattributeElemContext {
	children := s.GetChildren()
	len := 0
	for _, ctx := range children {
		if _, ok := ctx.(IConstraintattributeElemContext); ok {
			len++
		}
	}

	tst := make([]IConstraintattributeElemContext, len)
	i := 0
	for _, ctx := range children {
		if t, ok := ctx.(IConstraintattributeElemContext); ok {
			tst[i] = t.(IConstraintattributeElemContext)
			i++
		}
	}

	return tst
}

func (s *ConstraintattributespecContext) ConstraintattributeElem(i int) IConstraintattributeElemContext {
	var t antlr.RuleContext
	j := 0
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IConstraintattributeElemContext); ok {
			if j == i {
				t = ctx.(antlr.RuleContext)
				break
			}
			j++
		}
	}

	if t == nil {
		return nil
	}

	return t.(IConstraintattributeElemContext)
}

func (s *ConstraintattributespecContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *ConstraintattributespecContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *ConstraintattributespecContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterConstraintattributespec(s)
	}
}

func (s *ConstraintattributespecContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitConstraintattributespec(s)
	}
}

func (s *ConstraintattributespecContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitConstraintattributespec(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Constraintattributespec() (localctx IConstraintattributespecContext) {
	localctx = NewConstraintattributespecContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 440, PostgreSQLParserRULE_constraintattributespec)
	var _la int

	p.EnterOuterAlt(localctx, 1)
	p.SetState(4030)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}
	_la = p.GetTokenStream().LA(1)

	for ((int64((_la-54)) & ^0x3f) == 0 && ((int64(1)<<(_la-54))&8421377) != 0) || _la == PostgreSQLParserNO {
		{
			p.SetState(4027)
			p.ConstraintattributeElem()
		}

		p.SetState(4032)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}
		_la = p.GetTokenStream().LA(1)
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IConstraintattributeElemContext is an interface to support dynamic dispatch.
type IConstraintattributeElemContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	NOT() antlr.TerminalNode
	DEFERRABLE() antlr.TerminalNode
	INITIALLY() antlr.TerminalNode
	IMMEDIATE() antlr.TerminalNode
	DEFERRED() antlr.TerminalNode
	VALID() antlr.TerminalNode
	NO() antlr.TerminalNode
	INHERIT() antlr.TerminalNode

	// IsConstraintattributeElemContext differentiates from other interfaces.
	IsConstraintattributeElemContext()
}

type ConstraintattributeElemContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyConstraintattributeElemContext() *ConstraintattributeElemContext {
	var p = new(ConstraintattributeElemContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_constraintattributeElem
	return p
}

func InitEmptyConstraintattributeElemContext(p *ConstraintattributeElemContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_constraintattributeElem
}

func (*ConstraintattributeElemContext) IsConstraintattributeElemContext() {}

func NewConstraintattributeElemContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ConstraintattributeElemContext {
	var p = new(ConstraintattributeElemContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_constraintattributeElem

	return p
}

func (s *ConstraintattributeElemContext) GetParser() antlr.Parser { return s.parser }

func (s *ConstraintattributeElemContext) NOT() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserNOT, 0)
}

func (s *ConstraintattributeElemContext) DEFERRABLE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserDEFERRABLE, 0)
}

func (s *ConstraintattributeElemContext) INITIALLY() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserINITIALLY, 0)
}

func (s *ConstraintattributeElemContext) IMMEDIATE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserIMMEDIATE, 0)
}

func (s *ConstraintattributeElemContext) DEFERRED() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserDEFERRED, 0)
}

func (s *ConstraintattributeElemContext) VALID() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserVALID, 0)
}

func (s *ConstraintattributeElemContext) NO() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserNO, 0)
}

func (s *ConstraintattributeElemContext) INHERIT() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserINHERIT, 0)
}

func (s *ConstraintattributeElemContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *ConstraintattributeElemContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *ConstraintattributeElemContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterConstraintattributeElem(s)
	}
}

func (s *ConstraintattributeElemContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitConstraintattributeElem(s)
	}
}

func (s *ConstraintattributeElemContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitConstraintattributeElem(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) ConstraintattributeElem() (localctx IConstraintattributeElemContext) {
	localctx = NewConstraintattributeElemContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 442, PostgreSQLParserRULE_constraintattributeElem)
	p.SetState(4044)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 193, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(4033)
			p.Match(PostgreSQLParserNOT)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4034)
			p.Match(PostgreSQLParserDEFERRABLE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(4035)
			p.Match(PostgreSQLParserDEFERRABLE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 3:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(4036)
			p.Match(PostgreSQLParserINITIALLY)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4037)
			p.Match(PostgreSQLParserIMMEDIATE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 4:
		p.EnterOuterAlt(localctx, 4)
		{
			p.SetState(4038)
			p.Match(PostgreSQLParserINITIALLY)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4039)
			p.Match(PostgreSQLParserDEFERRED)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 5:
		p.EnterOuterAlt(localctx, 5)
		{
			p.SetState(4040)
			p.Match(PostgreSQLParserNOT)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4041)
			p.Match(PostgreSQLParserVALID)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 6:
		p.EnterOuterAlt(localctx, 6)
		{
			p.SetState(4042)
			p.Match(PostgreSQLParserNO)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4043)
			p.Match(PostgreSQLParserINHERIT)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case antlr.ATNInvalidAltNumber:
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// ICreateeventtrigstmtContext is an interface to support dynamic dispatch.
type ICreateeventtrigstmtContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	CREATE() antlr.TerminalNode
	EVENT() antlr.TerminalNode
	TRIGGER() antlr.TerminalNode
	Name() INameContext
	ON() antlr.TerminalNode
	Collabel() ICollabelContext
	EXECUTE() antlr.TerminalNode
	Function_or_procedure() IFunction_or_procedureContext
	Func_name() IFunc_nameContext
	OPEN_PAREN() antlr.TerminalNode
	CLOSE_PAREN() antlr.TerminalNode
	WHEN() antlr.TerminalNode
	Event_trigger_when_list() IEvent_trigger_when_listContext

	// IsCreateeventtrigstmtContext differentiates from other interfaces.
	IsCreateeventtrigstmtContext()
}

type CreateeventtrigstmtContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyCreateeventtrigstmtContext() *CreateeventtrigstmtContext {
	var p = new(CreateeventtrigstmtContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_createeventtrigstmt
	return p
}

func InitEmptyCreateeventtrigstmtContext(p *CreateeventtrigstmtContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_createeventtrigstmt
}

func (*CreateeventtrigstmtContext) IsCreateeventtrigstmtContext() {}

func NewCreateeventtrigstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CreateeventtrigstmtContext {
	var p = new(CreateeventtrigstmtContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_createeventtrigstmt

	return p
}

func (s *CreateeventtrigstmtContext) GetParser() antlr.Parser { return s.parser }

func (s *CreateeventtrigstmtContext) CREATE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCREATE, 0)
}

func (s *CreateeventtrigstmtContext) EVENT() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserEVENT, 0)
}

func (s *CreateeventtrigstmtContext) TRIGGER() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserTRIGGER, 0)
}

func (s *CreateeventtrigstmtContext) Name() INameContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(INameContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(INameContext)
}

func (s *CreateeventtrigstmtContext) ON() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserON, 0)
}

func (s *CreateeventtrigstmtContext) Collabel() ICollabelContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ICollabelContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ICollabelContext)
}

func (s *CreateeventtrigstmtContext) EXECUTE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserEXECUTE, 0)
}

func (s *CreateeventtrigstmtContext) Function_or_procedure() IFunction_or_procedureContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IFunction_or_procedureContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IFunction_or_procedureContext)
}

func (s *CreateeventtrigstmtContext) Func_name() IFunc_nameContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IFunc_nameContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IFunc_nameContext)
}

func (s *CreateeventtrigstmtContext) OPEN_PAREN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserOPEN_PAREN, 0)
}

func (s *CreateeventtrigstmtContext) CLOSE_PAREN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCLOSE_PAREN, 0)
}

func (s *CreateeventtrigstmtContext) WHEN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserWHEN, 0)
}

func (s *CreateeventtrigstmtContext) Event_trigger_when_list() IEvent_trigger_when_listContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IEvent_trigger_when_listContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IEvent_trigger_when_listContext)
}

func (s *CreateeventtrigstmtContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *CreateeventtrigstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *CreateeventtrigstmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterCreateeventtrigstmt(s)
	}
}

func (s *CreateeventtrigstmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitCreateeventtrigstmt(s)
	}
}

func (s *CreateeventtrigstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitCreateeventtrigstmt(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Createeventtrigstmt() (localctx ICreateeventtrigstmtContext) {
	localctx = NewCreateeventtrigstmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 444, PostgreSQLParserRULE_createeventtrigstmt)
	p.SetState(4072)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 194, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(4046)
			p.Match(PostgreSQLParserCREATE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4047)
			p.Match(PostgreSQLParserEVENT)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4048)
			p.Match(PostgreSQLParserTRIGGER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4049)
			p.Name()
		}
		{
			p.SetState(4050)
			p.Match(PostgreSQLParserON)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4051)
			p.Collabel()
		}
		{
			p.SetState(4052)
			p.Match(PostgreSQLParserEXECUTE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4053)
			p.Function_or_procedure()
		}
		{
			p.SetState(4054)
			p.Func_name()
		}
		{
			p.SetState(4055)
			p.Match(PostgreSQLParserOPEN_PAREN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4056)
			p.Match(PostgreSQLParserCLOSE_PAREN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(4058)
			p.Match(PostgreSQLParserCREATE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4059)
			p.Match(PostgreSQLParserEVENT)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4060)
			p.Match(PostgreSQLParserTRIGGER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4061)
			p.Name()
		}
		{
			p.SetState(4062)
			p.Match(PostgreSQLParserON)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4063)
			p.Collabel()
		}
		{
			p.SetState(4064)
			p.Match(PostgreSQLParserWHEN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4065)
			p.Event_trigger_when_list()
		}
		{
			p.SetState(4066)
			p.Match(PostgreSQLParserEXECUTE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4067)
			p.Function_or_procedure()
		}
		{
			p.SetState(4068)
			p.Func_name()
		}
		{
			p.SetState(4069)
			p.Match(PostgreSQLParserOPEN_PAREN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4070)
			p.Match(PostgreSQLParserCLOSE_PAREN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case antlr.ATNInvalidAltNumber:
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IEvent_trigger_when_listContext is an interface to support dynamic dispatch.
type IEvent_trigger_when_listContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	AllEvent_trigger_when_item() []IEvent_trigger_when_itemContext
	Event_trigger_when_item(i int) IEvent_trigger_when_itemContext
	AllAND() []antlr.TerminalNode
	AND(i int) antlr.TerminalNode

	// IsEvent_trigger_when_listContext differentiates from other interfaces.
	IsEvent_trigger_when_listContext()
}

type Event_trigger_when_listContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyEvent_trigger_when_listContext() *Event_trigger_when_listContext {
	var p = new(Event_trigger_when_listContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_event_trigger_when_list
	return p
}

func InitEmptyEvent_trigger_when_listContext(p *Event_trigger_when_listContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_event_trigger_when_list
}

func (*Event_trigger_when_listContext) IsEvent_trigger_when_listContext() {}

func NewEvent_trigger_when_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Event_trigger_when_listContext {
	var p = new(Event_trigger_when_listContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_event_trigger_when_list

	return p
}

func (s *Event_trigger_when_listContext) GetParser() antlr.Parser { return s.parser }

func (s *Event_trigger_when_listContext) AllEvent_trigger_when_item() []IEvent_trigger_when_itemContext {
	children := s.GetChildren()
	len := 0
	for _, ctx := range children {
		if _, ok := ctx.(IEvent_trigger_when_itemContext); ok {
			len++
		}
	}

	tst := make([]IEvent_trigger_when_itemContext, len)
	i := 0
	for _, ctx := range children {
		if t, ok := ctx.(IEvent_trigger_when_itemContext); ok {
			tst[i] = t.(IEvent_trigger_when_itemContext)
			i++
		}
	}

	return tst
}

func (s *Event_trigger_when_listContext) Event_trigger_when_item(i int) IEvent_trigger_when_itemContext {
	var t antlr.RuleContext
	j := 0
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IEvent_trigger_when_itemContext); ok {
			if j == i {
				t = ctx.(antlr.RuleContext)
				break
			}
			j++
		}
	}

	if t == nil {
		return nil
	}

	return t.(IEvent_trigger_when_itemContext)
}

func (s *Event_trigger_when_listContext) AllAND() []antlr.TerminalNode {
	return s.GetTokens(PostgreSQLParserAND)
}

func (s *Event_trigger_when_listContext) AND(i int) antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserAND, i)
}

func (s *Event_trigger_when_listContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Event_trigger_when_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Event_trigger_when_listContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterEvent_trigger_when_list(s)
	}
}

func (s *Event_trigger_when_listContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitEvent_trigger_when_list(s)
	}
}

func (s *Event_trigger_when_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitEvent_trigger_when_list(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Event_trigger_when_list() (localctx IEvent_trigger_when_listContext) {
	localctx = NewEvent_trigger_when_listContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 446, PostgreSQLParserRULE_event_trigger_when_list)
	var _la int

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(4074)
		p.Event_trigger_when_item()
	}
	p.SetState(4079)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}
	_la = p.GetTokenStream().LA(1)

	for _la == PostgreSQLParserAND {
		{
			p.SetState(4075)
			p.Match(PostgreSQLParserAND)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4076)
			p.Event_trigger_when_item()
		}

		p.SetState(4081)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}
		_la = p.GetTokenStream().LA(1)
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IEvent_trigger_when_itemContext is an interface to support dynamic dispatch.
type IEvent_trigger_when_itemContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Colid() IColidContext
	IN_P() antlr.TerminalNode
	OPEN_PAREN() antlr.TerminalNode
	Event_trigger_value_list() IEvent_trigger_value_listContext
	CLOSE_PAREN() antlr.TerminalNode

	// IsEvent_trigger_when_itemContext differentiates from other interfaces.
	IsEvent_trigger_when_itemContext()
}

type Event_trigger_when_itemContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyEvent_trigger_when_itemContext() *Event_trigger_when_itemContext {
	var p = new(Event_trigger_when_itemContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_event_trigger_when_item
	return p
}

func InitEmptyEvent_trigger_when_itemContext(p *Event_trigger_when_itemContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_event_trigger_when_item
}

func (*Event_trigger_when_itemContext) IsEvent_trigger_when_itemContext() {}

func NewEvent_trigger_when_itemContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Event_trigger_when_itemContext {
	var p = new(Event_trigger_when_itemContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_event_trigger_when_item

	return p
}

func (s *Event_trigger_when_itemContext) GetParser() antlr.Parser { return s.parser }

func (s *Event_trigger_when_itemContext) Colid() IColidContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IColidContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IColidContext)
}

func (s *Event_trigger_when_itemContext) IN_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserIN_P, 0)
}

func (s *Event_trigger_when_itemContext) OPEN_PAREN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserOPEN_PAREN, 0)
}

func (s *Event_trigger_when_itemContext) Event_trigger_value_list() IEvent_trigger_value_listContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IEvent_trigger_value_listContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IEvent_trigger_value_listContext)
}

func (s *Event_trigger_when_itemContext) CLOSE_PAREN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCLOSE_PAREN, 0)
}

func (s *Event_trigger_when_itemContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Event_trigger_when_itemContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Event_trigger_when_itemContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterEvent_trigger_when_item(s)
	}
}

func (s *Event_trigger_when_itemContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitEvent_trigger_when_item(s)
	}
}

func (s *Event_trigger_when_itemContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitEvent_trigger_when_item(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Event_trigger_when_item() (localctx IEvent_trigger_when_itemContext) {
	localctx = NewEvent_trigger_when_itemContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 448, PostgreSQLParserRULE_event_trigger_when_item)
	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(4082)
		p.Colid()
	}
	{
		p.SetState(4083)
		p.Match(PostgreSQLParserIN_P)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(4084)
		p.Match(PostgreSQLParserOPEN_PAREN)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(4085)
		p.Event_trigger_value_list()
	}
	{
		p.SetState(4086)
		p.Match(PostgreSQLParserCLOSE_PAREN)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IEvent_trigger_value_listContext is an interface to support dynamic dispatch.
type IEvent_trigger_value_listContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	AllSconst() []ISconstContext
	Sconst(i int) ISconstContext
	AllCOMMA() []antlr.TerminalNode
	COMMA(i int) antlr.TerminalNode

	// IsEvent_trigger_value_listContext differentiates from other interfaces.
	IsEvent_trigger_value_listContext()
}

type Event_trigger_value_listContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyEvent_trigger_value_listContext() *Event_trigger_value_listContext {
	var p = new(Event_trigger_value_listContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_event_trigger_value_list
	return p
}

func InitEmptyEvent_trigger_value_listContext(p *Event_trigger_value_listContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_event_trigger_value_list
}

func (*Event_trigger_value_listContext) IsEvent_trigger_value_listContext() {}

func NewEvent_trigger_value_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Event_trigger_value_listContext {
	var p = new(Event_trigger_value_listContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_event_trigger_value_list

	return p
}

func (s *Event_trigger_value_listContext) GetParser() antlr.Parser { return s.parser }

func (s *Event_trigger_value_listContext) AllSconst() []ISconstContext {
	children := s.GetChildren()
	len := 0
	for _, ctx := range children {
		if _, ok := ctx.(ISconstContext); ok {
			len++
		}
	}

	tst := make([]ISconstContext, len)
	i := 0
	for _, ctx := range children {
		if t, ok := ctx.(ISconstContext); ok {
			tst[i] = t.(ISconstContext)
			i++
		}
	}

	return tst
}

func (s *Event_trigger_value_listContext) Sconst(i int) ISconstContext {
	var t antlr.RuleContext
	j := 0
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ISconstContext); ok {
			if j == i {
				t = ctx.(antlr.RuleContext)
				break
			}
			j++
		}
	}

	if t == nil {
		return nil
	}

	return t.(ISconstContext)
}

func (s *Event_trigger_value_listContext) AllCOMMA() []antlr.TerminalNode {
	return s.GetTokens(PostgreSQLParserCOMMA)
}

func (s *Event_trigger_value_listContext) COMMA(i int) antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCOMMA, i)
}

func (s *Event_trigger_value_listContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Event_trigger_value_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Event_trigger_value_listContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterEvent_trigger_value_list(s)
	}
}

func (s *Event_trigger_value_listContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitEvent_trigger_value_list(s)
	}
}

func (s *Event_trigger_value_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitEvent_trigger_value_list(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Event_trigger_value_list() (localctx IEvent_trigger_value_listContext) {
	localctx = NewEvent_trigger_value_listContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 450, PostgreSQLParserRULE_event_trigger_value_list)
	var _la int

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(4088)
		p.Sconst()
	}
	p.SetState(4093)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}
	_la = p.GetTokenStream().LA(1)

	for _la == PostgreSQLParserCOMMA {
		{
			p.SetState(4089)
			p.Match(PostgreSQLParserCOMMA)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4090)
			p.Sconst()
		}

		p.SetState(4095)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}
		_la = p.GetTokenStream().LA(1)
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IAltereventtrigstmtContext is an interface to support dynamic dispatch.
type IAltereventtrigstmtContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	ALTER() antlr.TerminalNode
	EVENT() antlr.TerminalNode
	TRIGGER() antlr.TerminalNode
	Name() INameContext
	Enable_trigger() IEnable_triggerContext

	// IsAltereventtrigstmtContext differentiates from other interfaces.
	IsAltereventtrigstmtContext()
}

type AltereventtrigstmtContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyAltereventtrigstmtContext() *AltereventtrigstmtContext {
	var p = new(AltereventtrigstmtContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_altereventtrigstmt
	return p
}

func InitEmptyAltereventtrigstmtContext(p *AltereventtrigstmtContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_altereventtrigstmt
}

func (*AltereventtrigstmtContext) IsAltereventtrigstmtContext() {}

func NewAltereventtrigstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AltereventtrigstmtContext {
	var p = new(AltereventtrigstmtContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_altereventtrigstmt

	return p
}

func (s *AltereventtrigstmtContext) GetParser() antlr.Parser { return s.parser }

func (s *AltereventtrigstmtContext) ALTER() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserALTER, 0)
}

func (s *AltereventtrigstmtContext) EVENT() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserEVENT, 0)
}

func (s *AltereventtrigstmtContext) TRIGGER() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserTRIGGER, 0)
}

func (s *AltereventtrigstmtContext) Name() INameContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(INameContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(INameContext)
}

func (s *AltereventtrigstmtContext) Enable_trigger() IEnable_triggerContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IEnable_triggerContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IEnable_triggerContext)
}

func (s *AltereventtrigstmtContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *AltereventtrigstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *AltereventtrigstmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterAltereventtrigstmt(s)
	}
}

func (s *AltereventtrigstmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitAltereventtrigstmt(s)
	}
}

func (s *AltereventtrigstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitAltereventtrigstmt(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Altereventtrigstmt() (localctx IAltereventtrigstmtContext) {
	localctx = NewAltereventtrigstmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 452, PostgreSQLParserRULE_altereventtrigstmt)
	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(4096)
		p.Match(PostgreSQLParserALTER)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(4097)
		p.Match(PostgreSQLParserEVENT)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(4098)
		p.Match(PostgreSQLParserTRIGGER)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(4099)
		p.Name()
	}
	{
		p.SetState(4100)
		p.Enable_trigger()
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IEnable_triggerContext is an interface to support dynamic dispatch.
type IEnable_triggerContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	ENABLE_P() antlr.TerminalNode
	REPLICA() antlr.TerminalNode
	ALWAYS() antlr.TerminalNode
	DISABLE_P() antlr.TerminalNode

	// IsEnable_triggerContext differentiates from other interfaces.
	IsEnable_triggerContext()
}

type Enable_triggerContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyEnable_triggerContext() *Enable_triggerContext {
	var p = new(Enable_triggerContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_enable_trigger
	return p
}

func InitEmptyEnable_triggerContext(p *Enable_triggerContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_enable_trigger
}

func (*Enable_triggerContext) IsEnable_triggerContext() {}

func NewEnable_triggerContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Enable_triggerContext {
	var p = new(Enable_triggerContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_enable_trigger

	return p
}

func (s *Enable_triggerContext) GetParser() antlr.Parser { return s.parser }

func (s *Enable_triggerContext) ENABLE_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserENABLE_P, 0)
}

func (s *Enable_triggerContext) REPLICA() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserREPLICA, 0)
}

func (s *Enable_triggerContext) ALWAYS() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserALWAYS, 0)
}

func (s *Enable_triggerContext) DISABLE_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserDISABLE_P, 0)
}

func (s *Enable_triggerContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Enable_triggerContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Enable_triggerContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterEnable_trigger(s)
	}
}

func (s *Enable_triggerContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitEnable_trigger(s)
	}
}

func (s *Enable_triggerContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitEnable_trigger(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Enable_trigger() (localctx IEnable_triggerContext) {
	localctx = NewEnable_triggerContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 454, PostgreSQLParserRULE_enable_trigger)
	p.SetState(4108)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 197, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(4102)
			p.Match(PostgreSQLParserENABLE_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(4103)
			p.Match(PostgreSQLParserENABLE_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4104)
			p.Match(PostgreSQLParserREPLICA)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 3:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(4105)
			p.Match(PostgreSQLParserENABLE_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4106)
			p.Match(PostgreSQLParserALWAYS)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 4:
		p.EnterOuterAlt(localctx, 4)
		{
			p.SetState(4107)
			p.Match(PostgreSQLParserDISABLE_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case antlr.ATNInvalidAltNumber:
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// ICreateassertionstmtContext is an interface to support dynamic dispatch.
type ICreateassertionstmtContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	CREATE() antlr.TerminalNode
	ASSERTION() antlr.TerminalNode
	Any_name() IAny_nameContext
	CHECK() antlr.TerminalNode
	OPEN_PAREN() antlr.TerminalNode
	A_expr() IA_exprContext
	CLOSE_PAREN() antlr.TerminalNode
	Constraintattributespec() IConstraintattributespecContext

	// IsCreateassertionstmtContext differentiates from other interfaces.
	IsCreateassertionstmtContext()
}

type CreateassertionstmtContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyCreateassertionstmtContext() *CreateassertionstmtContext {
	var p = new(CreateassertionstmtContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_createassertionstmt
	return p
}

func InitEmptyCreateassertionstmtContext(p *CreateassertionstmtContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_createassertionstmt
}

func (*CreateassertionstmtContext) IsCreateassertionstmtContext() {}

func NewCreateassertionstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CreateassertionstmtContext {
	var p = new(CreateassertionstmtContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_createassertionstmt

	return p
}

func (s *CreateassertionstmtContext) GetParser() antlr.Parser { return s.parser }

func (s *CreateassertionstmtContext) CREATE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCREATE, 0)
}

func (s *CreateassertionstmtContext) ASSERTION() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserASSERTION, 0)
}

func (s *CreateassertionstmtContext) Any_name() IAny_nameContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IAny_nameContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IAny_nameContext)
}

func (s *CreateassertionstmtContext) CHECK() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCHECK, 0)
}

func (s *CreateassertionstmtContext) OPEN_PAREN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserOPEN_PAREN, 0)
}

func (s *CreateassertionstmtContext) A_expr() IA_exprContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IA_exprContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IA_exprContext)
}

func (s *CreateassertionstmtContext) CLOSE_PAREN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCLOSE_PAREN, 0)
}

func (s *CreateassertionstmtContext) Constraintattributespec() IConstraintattributespecContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IConstraintattributespecContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IConstraintattributespecContext)
}

func (s *CreateassertionstmtContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *CreateassertionstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *CreateassertionstmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterCreateassertionstmt(s)
	}
}

func (s *CreateassertionstmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitCreateassertionstmt(s)
	}
}

func (s *CreateassertionstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitCreateassertionstmt(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Createassertionstmt() (localctx ICreateassertionstmtContext) {
	localctx = NewCreateassertionstmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 456, PostgreSQLParserRULE_createassertionstmt)
	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(4110)
		p.Match(PostgreSQLParserCREATE)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(4111)
		p.Match(PostgreSQLParserASSERTION)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(4112)
		p.Any_name()
	}
	{
		p.SetState(4113)
		p.Match(PostgreSQLParserCHECK)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(4114)
		p.Match(PostgreSQLParserOPEN_PAREN)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(4115)
		p.A_expr()
	}
	{
		p.SetState(4116)
		p.Match(PostgreSQLParserCLOSE_PAREN)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(4117)
		p.Constraintattributespec()
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IDefinestmtContext is an interface to support dynamic dispatch.
type IDefinestmtContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	CREATE() antlr.TerminalNode
	Opt_or_replace() IOpt_or_replaceContext
	AGGREGATE() antlr.TerminalNode
	Func_name() IFunc_nameContext
	Aggr_args() IAggr_argsContext
	Definition() IDefinitionContext
	Old_aggr_definition() IOld_aggr_definitionContext
	OPERATOR() antlr.TerminalNode
	Any_operator() IAny_operatorContext
	TYPE_P() antlr.TerminalNode
	AllAny_name() []IAny_nameContext
	Any_name(i int) IAny_nameContext
	AS() antlr.TerminalNode
	OPEN_PAREN() antlr.TerminalNode
	Opttablefuncelementlist() IOpttablefuncelementlistContext
	CLOSE_PAREN() antlr.TerminalNode
	ENUM_P() antlr.TerminalNode
	Opt_enum_val_list() IOpt_enum_val_listContext
	RANGE() antlr.TerminalNode
	TEXT_P() antlr.TerminalNode
	SEARCH() antlr.TerminalNode
	PARSER() antlr.TerminalNode
	DICTIONARY() antlr.TerminalNode
	TEMPLATE() antlr.TerminalNode
	CONFIGURATION() antlr.TerminalNode
	COLLATION() antlr.TerminalNode
	IF_P() antlr.TerminalNode
	NOT() antlr.TerminalNode
	EXISTS() antlr.TerminalNode
	FROM() antlr.TerminalNode

	// IsDefinestmtContext differentiates from other interfaces.
	IsDefinestmtContext()
}

type DefinestmtContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyDefinestmtContext() *DefinestmtContext {
	var p = new(DefinestmtContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_definestmt
	return p
}

func InitEmptyDefinestmtContext(p *DefinestmtContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_definestmt
}

func (*DefinestmtContext) IsDefinestmtContext() {}

func NewDefinestmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DefinestmtContext {
	var p = new(DefinestmtContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_definestmt

	return p
}

func (s *DefinestmtContext) GetParser() antlr.Parser { return s.parser }

func (s *DefinestmtContext) CREATE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCREATE, 0)
}

func (s *DefinestmtContext) Opt_or_replace() IOpt_or_replaceContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOpt_or_replaceContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOpt_or_replaceContext)
}

func (s *DefinestmtContext) AGGREGATE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserAGGREGATE, 0)
}

func (s *DefinestmtContext) Func_name() IFunc_nameContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IFunc_nameContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IFunc_nameContext)
}

func (s *DefinestmtContext) Aggr_args() IAggr_argsContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IAggr_argsContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IAggr_argsContext)
}

func (s *DefinestmtContext) Definition() IDefinitionContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IDefinitionContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IDefinitionContext)
}

func (s *DefinestmtContext) Old_aggr_definition() IOld_aggr_definitionContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOld_aggr_definitionContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOld_aggr_definitionContext)
}

func (s *DefinestmtContext) OPERATOR() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserOPERATOR, 0)
}

func (s *DefinestmtContext) Any_operator() IAny_operatorContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IAny_operatorContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IAny_operatorContext)
}

func (s *DefinestmtContext) TYPE_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserTYPE_P, 0)
}

func (s *DefinestmtContext) AllAny_name() []IAny_nameContext {
	children := s.GetChildren()
	len := 0
	for _, ctx := range children {
		if _, ok := ctx.(IAny_nameContext); ok {
			len++
		}
	}

	tst := make([]IAny_nameContext, len)
	i := 0
	for _, ctx := range children {
		if t, ok := ctx.(IAny_nameContext); ok {
			tst[i] = t.(IAny_nameContext)
			i++
		}
	}

	return tst
}

func (s *DefinestmtContext) Any_name(i int) IAny_nameContext {
	var t antlr.RuleContext
	j := 0
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IAny_nameContext); ok {
			if j == i {
				t = ctx.(antlr.RuleContext)
				break
			}
			j++
		}
	}

	if t == nil {
		return nil
	}

	return t.(IAny_nameContext)
}

func (s *DefinestmtContext) AS() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserAS, 0)
}

func (s *DefinestmtContext) OPEN_PAREN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserOPEN_PAREN, 0)
}

func (s *DefinestmtContext) Opttablefuncelementlist() IOpttablefuncelementlistContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOpttablefuncelementlistContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOpttablefuncelementlistContext)
}

func (s *DefinestmtContext) CLOSE_PAREN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCLOSE_PAREN, 0)
}

func (s *DefinestmtContext) ENUM_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserENUM_P, 0)
}

func (s *DefinestmtContext) Opt_enum_val_list() IOpt_enum_val_listContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOpt_enum_val_listContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOpt_enum_val_listContext)
}

func (s *DefinestmtContext) RANGE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserRANGE, 0)
}

func (s *DefinestmtContext) TEXT_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserTEXT_P, 0)
}

func (s *DefinestmtContext) SEARCH() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserSEARCH, 0)
}

func (s *DefinestmtContext) PARSER() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserPARSER, 0)
}

func (s *DefinestmtContext) DICTIONARY() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserDICTIONARY, 0)
}

func (s *DefinestmtContext) TEMPLATE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserTEMPLATE, 0)
}

func (s *DefinestmtContext) CONFIGURATION() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCONFIGURATION, 0)
}

func (s *DefinestmtContext) COLLATION() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCOLLATION, 0)
}

func (s *DefinestmtContext) IF_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserIF_P, 0)
}

func (s *DefinestmtContext) NOT() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserNOT, 0)
}

func (s *DefinestmtContext) EXISTS() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserEXISTS, 0)
}

func (s *DefinestmtContext) FROM() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserFROM, 0)
}

func (s *DefinestmtContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *DefinestmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *DefinestmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterDefinestmt(s)
	}
}

func (s *DefinestmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitDefinestmt(s)
	}
}

func (s *DefinestmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitDefinestmt(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Definestmt() (localctx IDefinestmtContext) {
	localctx = NewDefinestmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 458, PostgreSQLParserRULE_definestmt)
	p.SetState(4225)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 198, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(4119)
			p.Match(PostgreSQLParserCREATE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4120)
			p.Opt_or_replace()
		}
		{
			p.SetState(4121)
			p.Match(PostgreSQLParserAGGREGATE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4122)
			p.Func_name()
		}
		{
			p.SetState(4123)
			p.Aggr_args()
		}
		{
			p.SetState(4124)
			p.Definition()
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(4126)
			p.Match(PostgreSQLParserCREATE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4127)
			p.Opt_or_replace()
		}
		{
			p.SetState(4128)
			p.Match(PostgreSQLParserAGGREGATE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4129)
			p.Func_name()
		}
		{
			p.SetState(4130)
			p.Old_aggr_definition()
		}

	case 3:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(4132)
			p.Match(PostgreSQLParserCREATE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4133)
			p.Match(PostgreSQLParserOPERATOR)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4134)
			p.Any_operator()
		}
		{
			p.SetState(4135)
			p.Definition()
		}

	case 4:
		p.EnterOuterAlt(localctx, 4)
		{
			p.SetState(4137)
			p.Match(PostgreSQLParserCREATE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4138)
			p.Match(PostgreSQLParserTYPE_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4139)
			p.Any_name()
		}
		{
			p.SetState(4140)
			p.Definition()
		}

	case 5:
		p.EnterOuterAlt(localctx, 5)
		{
			p.SetState(4142)
			p.Match(PostgreSQLParserCREATE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4143)
			p.Match(PostgreSQLParserTYPE_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4144)
			p.Any_name()
		}

	case 6:
		p.EnterOuterAlt(localctx, 6)
		{
			p.SetState(4145)
			p.Match(PostgreSQLParserCREATE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4146)
			p.Match(PostgreSQLParserTYPE_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4147)
			p.Any_name()
		}
		{
			p.SetState(4148)
			p.Match(PostgreSQLParserAS)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4149)
			p.Match(PostgreSQLParserOPEN_PAREN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4150)
			p.Opttablefuncelementlist()
		}
		{
			p.SetState(4151)
			p.Match(PostgreSQLParserCLOSE_PAREN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 7:
		p.EnterOuterAlt(localctx, 7)
		{
			p.SetState(4153)
			p.Match(PostgreSQLParserCREATE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4154)
			p.Match(PostgreSQLParserTYPE_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4155)
			p.Any_name()
		}
		{
			p.SetState(4156)
			p.Match(PostgreSQLParserAS)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4157)
			p.Match(PostgreSQLParserENUM_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4158)
			p.Match(PostgreSQLParserOPEN_PAREN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4159)
			p.Opt_enum_val_list()
		}
		{
			p.SetState(4160)
			p.Match(PostgreSQLParserCLOSE_PAREN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 8:
		p.EnterOuterAlt(localctx, 8)
		{
			p.SetState(4162)
			p.Match(PostgreSQLParserCREATE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4163)
			p.Match(PostgreSQLParserTYPE_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4164)
			p.Any_name()
		}
		{
			p.SetState(4165)
			p.Match(PostgreSQLParserAS)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4166)
			p.Match(PostgreSQLParserRANGE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4167)
			p.Definition()
		}

	case 9:
		p.EnterOuterAlt(localctx, 9)
		{
			p.SetState(4169)
			p.Match(PostgreSQLParserCREATE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4170)
			p.Match(PostgreSQLParserTEXT_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4171)
			p.Match(PostgreSQLParserSEARCH)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4172)
			p.Match(PostgreSQLParserPARSER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4173)
			p.Any_name()
		}
		{
			p.SetState(4174)
			p.Definition()
		}

	case 10:
		p.EnterOuterAlt(localctx, 10)
		{
			p.SetState(4176)
			p.Match(PostgreSQLParserCREATE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4177)
			p.Match(PostgreSQLParserTEXT_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4178)
			p.Match(PostgreSQLParserSEARCH)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4179)
			p.Match(PostgreSQLParserDICTIONARY)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4180)
			p.Any_name()
		}
		{
			p.SetState(4181)
			p.Definition()
		}

	case 11:
		p.EnterOuterAlt(localctx, 11)
		{
			p.SetState(4183)
			p.Match(PostgreSQLParserCREATE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4184)
			p.Match(PostgreSQLParserTEXT_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4185)
			p.Match(PostgreSQLParserSEARCH)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4186)
			p.Match(PostgreSQLParserTEMPLATE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4187)
			p.Any_name()
		}
		{
			p.SetState(4188)
			p.Definition()
		}

	case 12:
		p.EnterOuterAlt(localctx, 12)
		{
			p.SetState(4190)
			p.Match(PostgreSQLParserCREATE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4191)
			p.Match(PostgreSQLParserTEXT_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4192)
			p.Match(PostgreSQLParserSEARCH)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4193)
			p.Match(PostgreSQLParserCONFIGURATION)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4194)
			p.Any_name()
		}
		{
			p.SetState(4195)
			p.Definition()
		}

	case 13:
		p.EnterOuterAlt(localctx, 13)
		{
			p.SetState(4197)
			p.Match(PostgreSQLParserCREATE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4198)
			p.Match(PostgreSQLParserCOLLATION)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4199)
			p.Any_name()
		}
		{
			p.SetState(4200)
			p.Definition()
		}

	case 14:
		p.EnterOuterAlt(localctx, 14)
		{
			p.SetState(4202)
			p.Match(PostgreSQLParserCREATE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4203)
			p.Match(PostgreSQLParserCOLLATION)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4204)
			p.Match(PostgreSQLParserIF_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4205)
			p.Match(PostgreSQLParserNOT)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4206)
			p.Match(PostgreSQLParserEXISTS)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4207)
			p.Any_name()
		}
		{
			p.SetState(4208)
			p.Definition()
		}

	case 15:
		p.EnterOuterAlt(localctx, 15)
		{
			p.SetState(4210)
			p.Match(PostgreSQLParserCREATE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4211)
			p.Match(PostgreSQLParserCOLLATION)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4212)
			p.Any_name()
		}
		{
			p.SetState(4213)
			p.Match(PostgreSQLParserFROM)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4214)
			p.Any_name()
		}

	case 16:
		p.EnterOuterAlt(localctx, 16)
		{
			p.SetState(4216)
			p.Match(PostgreSQLParserCREATE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4217)
			p.Match(PostgreSQLParserCOLLATION)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4218)
			p.Match(PostgreSQLParserIF_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4219)
			p.Match(PostgreSQLParserNOT)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4220)
			p.Match(PostgreSQLParserEXISTS)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4221)
			p.Any_name()
		}
		{
			p.SetState(4222)
			p.Match(PostgreSQLParserFROM)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4223)
			p.Any_name()
		}

	case antlr.ATNInvalidAltNumber:
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IDefinitionContext is an interface to support dynamic dispatch.
type IDefinitionContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	OPEN_PAREN() antlr.TerminalNode
	Def_list() IDef_listContext
	CLOSE_PAREN() antlr.TerminalNode

	// IsDefinitionContext differentiates from other interfaces.
	IsDefinitionContext()
}

type DefinitionContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyDefinitionContext() *DefinitionContext {
	var p = new(DefinitionContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_definition
	return p
}

func InitEmptyDefinitionContext(p *DefinitionContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_definition
}

func (*DefinitionContext) IsDefinitionContext() {}

func NewDefinitionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DefinitionContext {
	var p = new(DefinitionContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_definition

	return p
}

func (s *DefinitionContext) GetParser() antlr.Parser { return s.parser }

func (s *DefinitionContext) OPEN_PAREN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserOPEN_PAREN, 0)
}

func (s *DefinitionContext) Def_list() IDef_listContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IDef_listContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IDef_listContext)
}

func (s *DefinitionContext) CLOSE_PAREN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCLOSE_PAREN, 0)
}

func (s *DefinitionContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *DefinitionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *DefinitionContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterDefinition(s)
	}
}

func (s *DefinitionContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitDefinition(s)
	}
}

func (s *DefinitionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitDefinition(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Definition() (localctx IDefinitionContext) {
	localctx = NewDefinitionContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 460, PostgreSQLParserRULE_definition)
	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(4227)
		p.Match(PostgreSQLParserOPEN_PAREN)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(4228)
		p.Def_list()
	}
	{
		p.SetState(4229)
		p.Match(PostgreSQLParserCLOSE_PAREN)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IDef_listContext is an interface to support dynamic dispatch.
type IDef_listContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	AllDef_elem() []IDef_elemContext
	Def_elem(i int) IDef_elemContext
	AllCOMMA() []antlr.TerminalNode
	COMMA(i int) antlr.TerminalNode

	// IsDef_listContext differentiates from other interfaces.
	IsDef_listContext()
}

type Def_listContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyDef_listContext() *Def_listContext {
	var p = new(Def_listContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_def_list
	return p
}

func InitEmptyDef_listContext(p *Def_listContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_def_list
}

func (*Def_listContext) IsDef_listContext() {}

func NewDef_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Def_listContext {
	var p = new(Def_listContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_def_list

	return p
}

func (s *Def_listContext) GetParser() antlr.Parser { return s.parser }

func (s *Def_listContext) AllDef_elem() []IDef_elemContext {
	children := s.GetChildren()
	len := 0
	for _, ctx := range children {
		if _, ok := ctx.(IDef_elemContext); ok {
			len++
		}
	}

	tst := make([]IDef_elemContext, len)
	i := 0
	for _, ctx := range children {
		if t, ok := ctx.(IDef_elemContext); ok {
			tst[i] = t.(IDef_elemContext)
			i++
		}
	}

	return tst
}

func (s *Def_listContext) Def_elem(i int) IDef_elemContext {
	var t antlr.RuleContext
	j := 0
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IDef_elemContext); ok {
			if j == i {
				t = ctx.(antlr.RuleContext)
				break
			}
			j++
		}
	}

	if t == nil {
		return nil
	}

	return t.(IDef_elemContext)
}

func (s *Def_listContext) AllCOMMA() []antlr.TerminalNode {
	return s.GetTokens(PostgreSQLParserCOMMA)
}

func (s *Def_listContext) COMMA(i int) antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCOMMA, i)
}

func (s *Def_listContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Def_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Def_listContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterDef_list(s)
	}
}

func (s *Def_listContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitDef_list(s)
	}
}

func (s *Def_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitDef_list(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Def_list() (localctx IDef_listContext) {
	localctx = NewDef_listContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 462, PostgreSQLParserRULE_def_list)
	var _la int

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(4231)
		p.Def_elem()
	}
	p.SetState(4236)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}
	_la = p.GetTokenStream().LA(1)

	for _la == PostgreSQLParserCOMMA {
		{
			p.SetState(4232)
			p.Match(PostgreSQLParserCOMMA)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4233)
			p.Def_elem()
		}

		p.SetState(4238)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}
		_la = p.GetTokenStream().LA(1)
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IDef_elemContext is an interface to support dynamic dispatch.
type IDef_elemContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Collabel() ICollabelContext
	EQUAL() antlr.TerminalNode
	Def_arg() IDef_argContext

	// IsDef_elemContext differentiates from other interfaces.
	IsDef_elemContext()
}

type Def_elemContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyDef_elemContext() *Def_elemContext {
	var p = new(Def_elemContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_def_elem
	return p
}

func InitEmptyDef_elemContext(p *Def_elemContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_def_elem
}

func (*Def_elemContext) IsDef_elemContext() {}

func NewDef_elemContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Def_elemContext {
	var p = new(Def_elemContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_def_elem

	return p
}

func (s *Def_elemContext) GetParser() antlr.Parser { return s.parser }

func (s *Def_elemContext) Collabel() ICollabelContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ICollabelContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ICollabelContext)
}

func (s *Def_elemContext) EQUAL() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserEQUAL, 0)
}

func (s *Def_elemContext) Def_arg() IDef_argContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IDef_argContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IDef_argContext)
}

func (s *Def_elemContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Def_elemContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Def_elemContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterDef_elem(s)
	}
}

func (s *Def_elemContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitDef_elem(s)
	}
}

func (s *Def_elemContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitDef_elem(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Def_elem() (localctx IDef_elemContext) {
	localctx = NewDef_elemContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 464, PostgreSQLParserRULE_def_elem)
	var _la int

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(4239)
		p.Collabel()
	}
	p.SetState(4242)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}
	_la = p.GetTokenStream().LA(1)

	if _la == PostgreSQLParserEQUAL {
		{
			p.SetState(4240)
			p.Match(PostgreSQLParserEQUAL)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4241)
			p.Def_arg()
		}

	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IDef_argContext is an interface to support dynamic dispatch.
type IDef_argContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Func_type() IFunc_typeContext
	Reserved_keyword() IReserved_keywordContext
	Qual_all_op() IQual_all_opContext
	Numericonly() INumericonlyContext
	Sconst() ISconstContext
	NONE() antlr.TerminalNode

	// IsDef_argContext differentiates from other interfaces.
	IsDef_argContext()
}

type Def_argContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyDef_argContext() *Def_argContext {
	var p = new(Def_argContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_def_arg
	return p
}

func InitEmptyDef_argContext(p *Def_argContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_def_arg
}

func (*Def_argContext) IsDef_argContext() {}

func NewDef_argContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Def_argContext {
	var p = new(Def_argContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_def_arg

	return p
}

func (s *Def_argContext) GetParser() antlr.Parser { return s.parser }

func (s *Def_argContext) Func_type() IFunc_typeContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IFunc_typeContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IFunc_typeContext)
}

func (s *Def_argContext) Reserved_keyword() IReserved_keywordContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IReserved_keywordContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IReserved_keywordContext)
}

func (s *Def_argContext) Qual_all_op() IQual_all_opContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IQual_all_opContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IQual_all_opContext)
}

func (s *Def_argContext) Numericonly() INumericonlyContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(INumericonlyContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(INumericonlyContext)
}

func (s *Def_argContext) Sconst() ISconstContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ISconstContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ISconstContext)
}

func (s *Def_argContext) NONE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserNONE, 0)
}

func (s *Def_argContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Def_argContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Def_argContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterDef_arg(s)
	}
}

func (s *Def_argContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitDef_arg(s)
	}
}

func (s *Def_argContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitDef_arg(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Def_arg() (localctx IDef_argContext) {
	localctx = NewDef_argContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 466, PostgreSQLParserRULE_def_arg)
	p.SetState(4250)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 201, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(4244)
			p.Func_type()
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(4245)
			p.Reserved_keyword()
		}

	case 3:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(4246)
			p.Qual_all_op()
		}

	case 4:
		p.EnterOuterAlt(localctx, 4)
		{
			p.SetState(4247)
			p.Numericonly()
		}

	case 5:
		p.EnterOuterAlt(localctx, 5)
		{
			p.SetState(4248)
			p.Sconst()
		}

	case 6:
		p.EnterOuterAlt(localctx, 6)
		{
			p.SetState(4249)
			p.Match(PostgreSQLParserNONE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case antlr.ATNInvalidAltNumber:
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IOld_aggr_definitionContext is an interface to support dynamic dispatch.
type IOld_aggr_definitionContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	OPEN_PAREN() antlr.TerminalNode
	Old_aggr_list() IOld_aggr_listContext
	CLOSE_PAREN() antlr.TerminalNode

	// IsOld_aggr_definitionContext differentiates from other interfaces.
	IsOld_aggr_definitionContext()
}

type Old_aggr_definitionContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyOld_aggr_definitionContext() *Old_aggr_definitionContext {
	var p = new(Old_aggr_definitionContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_old_aggr_definition
	return p
}

func InitEmptyOld_aggr_definitionContext(p *Old_aggr_definitionContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_old_aggr_definition
}

func (*Old_aggr_definitionContext) IsOld_aggr_definitionContext() {}

func NewOld_aggr_definitionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Old_aggr_definitionContext {
	var p = new(Old_aggr_definitionContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_old_aggr_definition

	return p
}

func (s *Old_aggr_definitionContext) GetParser() antlr.Parser { return s.parser }

func (s *Old_aggr_definitionContext) OPEN_PAREN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserOPEN_PAREN, 0)
}

func (s *Old_aggr_definitionContext) Old_aggr_list() IOld_aggr_listContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOld_aggr_listContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOld_aggr_listContext)
}

func (s *Old_aggr_definitionContext) CLOSE_PAREN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCLOSE_PAREN, 0)
}

func (s *Old_aggr_definitionContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Old_aggr_definitionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Old_aggr_definitionContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterOld_aggr_definition(s)
	}
}

func (s *Old_aggr_definitionContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitOld_aggr_definition(s)
	}
}

func (s *Old_aggr_definitionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitOld_aggr_definition(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Old_aggr_definition() (localctx IOld_aggr_definitionContext) {
	localctx = NewOld_aggr_definitionContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 468, PostgreSQLParserRULE_old_aggr_definition)
	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(4252)
		p.Match(PostgreSQLParserOPEN_PAREN)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(4253)
		p.Old_aggr_list()
	}
	{
		p.SetState(4254)
		p.Match(PostgreSQLParserCLOSE_PAREN)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IOld_aggr_listContext is an interface to support dynamic dispatch.
type IOld_aggr_listContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	AllOld_aggr_elem() []IOld_aggr_elemContext
	Old_aggr_elem(i int) IOld_aggr_elemContext
	AllCOMMA() []antlr.TerminalNode
	COMMA(i int) antlr.TerminalNode

	// IsOld_aggr_listContext differentiates from other interfaces.
	IsOld_aggr_listContext()
}

type Old_aggr_listContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyOld_aggr_listContext() *Old_aggr_listContext {
	var p = new(Old_aggr_listContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_old_aggr_list
	return p
}

func InitEmptyOld_aggr_listContext(p *Old_aggr_listContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_old_aggr_list
}

func (*Old_aggr_listContext) IsOld_aggr_listContext() {}

func NewOld_aggr_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Old_aggr_listContext {
	var p = new(Old_aggr_listContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_old_aggr_list

	return p
}

func (s *Old_aggr_listContext) GetParser() antlr.Parser { return s.parser }

func (s *Old_aggr_listContext) AllOld_aggr_elem() []IOld_aggr_elemContext {
	children := s.GetChildren()
	len := 0
	for _, ctx := range children {
		if _, ok := ctx.(IOld_aggr_elemContext); ok {
			len++
		}
	}

	tst := make([]IOld_aggr_elemContext, len)
	i := 0
	for _, ctx := range children {
		if t, ok := ctx.(IOld_aggr_elemContext); ok {
			tst[i] = t.(IOld_aggr_elemContext)
			i++
		}
	}

	return tst
}

func (s *Old_aggr_listContext) Old_aggr_elem(i int) IOld_aggr_elemContext {
	var t antlr.RuleContext
	j := 0
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOld_aggr_elemContext); ok {
			if j == i {
				t = ctx.(antlr.RuleContext)
				break
			}
			j++
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOld_aggr_elemContext)
}

func (s *Old_aggr_listContext) AllCOMMA() []antlr.TerminalNode {
	return s.GetTokens(PostgreSQLParserCOMMA)
}

func (s *Old_aggr_listContext) COMMA(i int) antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCOMMA, i)
}

func (s *Old_aggr_listContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Old_aggr_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Old_aggr_listContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterOld_aggr_list(s)
	}
}

func (s *Old_aggr_listContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitOld_aggr_list(s)
	}
}

func (s *Old_aggr_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitOld_aggr_list(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Old_aggr_list() (localctx IOld_aggr_listContext) {
	localctx = NewOld_aggr_listContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 470, PostgreSQLParserRULE_old_aggr_list)
	var _la int

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(4256)
		p.Old_aggr_elem()
	}
	p.SetState(4261)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}
	_la = p.GetTokenStream().LA(1)

	for _la == PostgreSQLParserCOMMA {
		{
			p.SetState(4257)
			p.Match(PostgreSQLParserCOMMA)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4258)
			p.Old_aggr_elem()
		}

		p.SetState(4263)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}
		_la = p.GetTokenStream().LA(1)
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IOld_aggr_elemContext is an interface to support dynamic dispatch.
type IOld_aggr_elemContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Identifier() IIdentifierContext
	EQUAL() antlr.TerminalNode
	Def_arg() IDef_argContext

	// IsOld_aggr_elemContext differentiates from other interfaces.
	IsOld_aggr_elemContext()
}

type Old_aggr_elemContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyOld_aggr_elemContext() *Old_aggr_elemContext {
	var p = new(Old_aggr_elemContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_old_aggr_elem
	return p
}

func InitEmptyOld_aggr_elemContext(p *Old_aggr_elemContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_old_aggr_elem
}

func (*Old_aggr_elemContext) IsOld_aggr_elemContext() {}

func NewOld_aggr_elemContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Old_aggr_elemContext {
	var p = new(Old_aggr_elemContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_old_aggr_elem

	return p
}

func (s *Old_aggr_elemContext) GetParser() antlr.Parser { return s.parser }

func (s *Old_aggr_elemContext) Identifier() IIdentifierContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IIdentifierContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IIdentifierContext)
}

func (s *Old_aggr_elemContext) EQUAL() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserEQUAL, 0)
}

func (s *Old_aggr_elemContext) Def_arg() IDef_argContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IDef_argContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IDef_argContext)
}

func (s *Old_aggr_elemContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Old_aggr_elemContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Old_aggr_elemContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterOld_aggr_elem(s)
	}
}

func (s *Old_aggr_elemContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitOld_aggr_elem(s)
	}
}

func (s *Old_aggr_elemContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitOld_aggr_elem(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Old_aggr_elem() (localctx IOld_aggr_elemContext) {
	localctx = NewOld_aggr_elemContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 472, PostgreSQLParserRULE_old_aggr_elem)
	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(4264)
		p.Identifier()
	}
	{
		p.SetState(4265)
		p.Match(PostgreSQLParserEQUAL)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(4266)
		p.Def_arg()
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IOpt_enum_val_listContext is an interface to support dynamic dispatch.
type IOpt_enum_val_listContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Enum_val_list() IEnum_val_listContext

	// IsOpt_enum_val_listContext differentiates from other interfaces.
	IsOpt_enum_val_listContext()
}

type Opt_enum_val_listContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyOpt_enum_val_listContext() *Opt_enum_val_listContext {
	var p = new(Opt_enum_val_listContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opt_enum_val_list
	return p
}

func InitEmptyOpt_enum_val_listContext(p *Opt_enum_val_listContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opt_enum_val_list
}

func (*Opt_enum_val_listContext) IsOpt_enum_val_listContext() {}

func NewOpt_enum_val_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_enum_val_listContext {
	var p = new(Opt_enum_val_listContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_opt_enum_val_list

	return p
}

func (s *Opt_enum_val_listContext) GetParser() antlr.Parser { return s.parser }

func (s *Opt_enum_val_listContext) Enum_val_list() IEnum_val_listContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IEnum_val_listContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IEnum_val_listContext)
}

func (s *Opt_enum_val_listContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Opt_enum_val_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Opt_enum_val_listContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterOpt_enum_val_list(s)
	}
}

func (s *Opt_enum_val_listContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitOpt_enum_val_list(s)
	}
}

func (s *Opt_enum_val_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitOpt_enum_val_list(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Opt_enum_val_list() (localctx IOpt_enum_val_listContext) {
	localctx = NewOpt_enum_val_listContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 474, PostgreSQLParserRULE_opt_enum_val_list)
	p.SetState(4270)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetTokenStream().LA(1) {
	case PostgreSQLParserStringConstant, PostgreSQLParserUnicodeEscapeStringConstant, PostgreSQLParserBeginDollarStringConstant, PostgreSQLParserEscapeStringConstant:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(4268)
			p.Enum_val_list()
		}

	case PostgreSQLParserCLOSE_PAREN:
		p.EnterOuterAlt(localctx, 2)

	default:
		p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IEnum_val_listContext is an interface to support dynamic dispatch.
type IEnum_val_listContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	AllSconst() []ISconstContext
	Sconst(i int) ISconstContext
	AllCOMMA() []antlr.TerminalNode
	COMMA(i int) antlr.TerminalNode

	// IsEnum_val_listContext differentiates from other interfaces.
	IsEnum_val_listContext()
}

type Enum_val_listContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyEnum_val_listContext() *Enum_val_listContext {
	var p = new(Enum_val_listContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_enum_val_list
	return p
}

func InitEmptyEnum_val_listContext(p *Enum_val_listContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_enum_val_list
}

func (*Enum_val_listContext) IsEnum_val_listContext() {}

func NewEnum_val_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Enum_val_listContext {
	var p = new(Enum_val_listContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_enum_val_list

	return p
}

func (s *Enum_val_listContext) GetParser() antlr.Parser { return s.parser }

func (s *Enum_val_listContext) AllSconst() []ISconstContext {
	children := s.GetChildren()
	len := 0
	for _, ctx := range children {
		if _, ok := ctx.(ISconstContext); ok {
			len++
		}
	}

	tst := make([]ISconstContext, len)
	i := 0
	for _, ctx := range children {
		if t, ok := ctx.(ISconstContext); ok {
			tst[i] = t.(ISconstContext)
			i++
		}
	}

	return tst
}

func (s *Enum_val_listContext) Sconst(i int) ISconstContext {
	var t antlr.RuleContext
	j := 0
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ISconstContext); ok {
			if j == i {
				t = ctx.(antlr.RuleContext)
				break
			}
			j++
		}
	}

	if t == nil {
		return nil
	}

	return t.(ISconstContext)
}

func (s *Enum_val_listContext) AllCOMMA() []antlr.TerminalNode {
	return s.GetTokens(PostgreSQLParserCOMMA)
}

func (s *Enum_val_listContext) COMMA(i int) antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCOMMA, i)
}

func (s *Enum_val_listContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Enum_val_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Enum_val_listContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterEnum_val_list(s)
	}
}

func (s *Enum_val_listContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitEnum_val_list(s)
	}
}

func (s *Enum_val_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitEnum_val_list(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Enum_val_list() (localctx IEnum_val_listContext) {
	localctx = NewEnum_val_listContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 476, PostgreSQLParserRULE_enum_val_list)
	var _la int

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(4272)
		p.Sconst()
	}
	p.SetState(4277)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}
	_la = p.GetTokenStream().LA(1)

	for _la == PostgreSQLParserCOMMA {
		{
			p.SetState(4273)
			p.Match(PostgreSQLParserCOMMA)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4274)
			p.Sconst()
		}

		p.SetState(4279)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}
		_la = p.GetTokenStream().LA(1)
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IAlterenumstmtContext is an interface to support dynamic dispatch.
type IAlterenumstmtContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	ALTER() antlr.TerminalNode
	TYPE_P() antlr.TerminalNode
	Any_name() IAny_nameContext
	ADD_P() antlr.TerminalNode
	VALUE_P() antlr.TerminalNode
	Opt_if_not_exists() IOpt_if_not_existsContext
	AllSconst() []ISconstContext
	Sconst(i int) ISconstContext
	BEFORE() antlr.TerminalNode
	AFTER() antlr.TerminalNode
	RENAME() antlr.TerminalNode
	TO() antlr.TerminalNode

	// IsAlterenumstmtContext differentiates from other interfaces.
	IsAlterenumstmtContext()
}

type AlterenumstmtContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyAlterenumstmtContext() *AlterenumstmtContext {
	var p = new(AlterenumstmtContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_alterenumstmt
	return p
}

func InitEmptyAlterenumstmtContext(p *AlterenumstmtContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_alterenumstmt
}

func (*AlterenumstmtContext) IsAlterenumstmtContext() {}

func NewAlterenumstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AlterenumstmtContext {
	var p = new(AlterenumstmtContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_alterenumstmt

	return p
}

func (s *AlterenumstmtContext) GetParser() antlr.Parser { return s.parser }

func (s *AlterenumstmtContext) ALTER() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserALTER, 0)
}

func (s *AlterenumstmtContext) TYPE_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserTYPE_P, 0)
}

func (s *AlterenumstmtContext) Any_name() IAny_nameContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IAny_nameContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IAny_nameContext)
}

func (s *AlterenumstmtContext) ADD_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserADD_P, 0)
}

func (s *AlterenumstmtContext) VALUE_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserVALUE_P, 0)
}

func (s *AlterenumstmtContext) Opt_if_not_exists() IOpt_if_not_existsContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOpt_if_not_existsContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOpt_if_not_existsContext)
}

func (s *AlterenumstmtContext) AllSconst() []ISconstContext {
	children := s.GetChildren()
	len := 0
	for _, ctx := range children {
		if _, ok := ctx.(ISconstContext); ok {
			len++
		}
	}

	tst := make([]ISconstContext, len)
	i := 0
	for _, ctx := range children {
		if t, ok := ctx.(ISconstContext); ok {
			tst[i] = t.(ISconstContext)
			i++
		}
	}

	return tst
}

func (s *AlterenumstmtContext) Sconst(i int) ISconstContext {
	var t antlr.RuleContext
	j := 0
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ISconstContext); ok {
			if j == i {
				t = ctx.(antlr.RuleContext)
				break
			}
			j++
		}
	}

	if t == nil {
		return nil
	}

	return t.(ISconstContext)
}

func (s *AlterenumstmtContext) BEFORE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserBEFORE, 0)
}

func (s *AlterenumstmtContext) AFTER() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserAFTER, 0)
}

func (s *AlterenumstmtContext) RENAME() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserRENAME, 0)
}

func (s *AlterenumstmtContext) TO() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserTO, 0)
}

func (s *AlterenumstmtContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *AlterenumstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *AlterenumstmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterAlterenumstmt(s)
	}
}

func (s *AlterenumstmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitAlterenumstmt(s)
	}
}

func (s *AlterenumstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitAlterenumstmt(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Alterenumstmt() (localctx IAlterenumstmtContext) {
	localctx = NewAlterenumstmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 478, PostgreSQLParserRULE_alterenumstmt)
	p.SetState(4317)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 205, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(4280)
			p.Match(PostgreSQLParserALTER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4281)
			p.Match(PostgreSQLParserTYPE_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4282)
			p.Any_name()
		}
		{
			p.SetState(4283)
			p.Match(PostgreSQLParserADD_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4284)
			p.Match(PostgreSQLParserVALUE_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4285)
			p.Opt_if_not_exists()
		}
		{
			p.SetState(4286)
			p.Sconst()
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(4288)
			p.Match(PostgreSQLParserALTER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4289)
			p.Match(PostgreSQLParserTYPE_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4290)
			p.Any_name()
		}
		{
			p.SetState(4291)
			p.Match(PostgreSQLParserADD_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4292)
			p.Match(PostgreSQLParserVALUE_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4293)
			p.Opt_if_not_exists()
		}
		{
			p.SetState(4294)
			p.Sconst()
		}
		{
			p.SetState(4295)
			p.Match(PostgreSQLParserBEFORE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4296)
			p.Sconst()
		}

	case 3:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(4298)
			p.Match(PostgreSQLParserALTER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4299)
			p.Match(PostgreSQLParserTYPE_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4300)
			p.Any_name()
		}
		{
			p.SetState(4301)
			p.Match(PostgreSQLParserADD_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4302)
			p.Match(PostgreSQLParserVALUE_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4303)
			p.Opt_if_not_exists()
		}
		{
			p.SetState(4304)
			p.Sconst()
		}
		{
			p.SetState(4305)
			p.Match(PostgreSQLParserAFTER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4306)
			p.Sconst()
		}

	case 4:
		p.EnterOuterAlt(localctx, 4)
		{
			p.SetState(4308)
			p.Match(PostgreSQLParserALTER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4309)
			p.Match(PostgreSQLParserTYPE_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4310)
			p.Any_name()
		}
		{
			p.SetState(4311)
			p.Match(PostgreSQLParserRENAME)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4312)
			p.Match(PostgreSQLParserVALUE_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4313)
			p.Sconst()
		}
		{
			p.SetState(4314)
			p.Match(PostgreSQLParserTO)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4315)
			p.Sconst()
		}

	case antlr.ATNInvalidAltNumber:
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IOpt_if_not_existsContext is an interface to support dynamic dispatch.
type IOpt_if_not_existsContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	IF_P() antlr.TerminalNode
	NOT() antlr.TerminalNode
	EXISTS() antlr.TerminalNode

	// IsOpt_if_not_existsContext differentiates from other interfaces.
	IsOpt_if_not_existsContext()
}

type Opt_if_not_existsContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyOpt_if_not_existsContext() *Opt_if_not_existsContext {
	var p = new(Opt_if_not_existsContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opt_if_not_exists
	return p
}

func InitEmptyOpt_if_not_existsContext(p *Opt_if_not_existsContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opt_if_not_exists
}

func (*Opt_if_not_existsContext) IsOpt_if_not_existsContext() {}

func NewOpt_if_not_existsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_if_not_existsContext {
	var p = new(Opt_if_not_existsContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_opt_if_not_exists

	return p
}

func (s *Opt_if_not_existsContext) GetParser() antlr.Parser { return s.parser }

func (s *Opt_if_not_existsContext) IF_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserIF_P, 0)
}

func (s *Opt_if_not_existsContext) NOT() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserNOT, 0)
}

func (s *Opt_if_not_existsContext) EXISTS() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserEXISTS, 0)
}

func (s *Opt_if_not_existsContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Opt_if_not_existsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Opt_if_not_existsContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterOpt_if_not_exists(s)
	}
}

func (s *Opt_if_not_existsContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitOpt_if_not_exists(s)
	}
}

func (s *Opt_if_not_existsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitOpt_if_not_exists(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Opt_if_not_exists() (localctx IOpt_if_not_existsContext) {
	localctx = NewOpt_if_not_existsContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 480, PostgreSQLParserRULE_opt_if_not_exists)
	p.SetState(4323)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetTokenStream().LA(1) {
	case PostgreSQLParserIF_P:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(4319)
			p.Match(PostgreSQLParserIF_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4320)
			p.Match(PostgreSQLParserNOT)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4321)
			p.Match(PostgreSQLParserEXISTS)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case PostgreSQLParserStringConstant, PostgreSQLParserUnicodeEscapeStringConstant, PostgreSQLParserBeginDollarStringConstant, PostgreSQLParserEscapeStringConstant:
		p.EnterOuterAlt(localctx, 2)

	default:
		p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// ICreateopclassstmtContext is an interface to support dynamic dispatch.
type ICreateopclassstmtContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	CREATE() antlr.TerminalNode
	OPERATOR() antlr.TerminalNode
	CLASS() antlr.TerminalNode
	Any_name() IAny_nameContext
	Opt_default() IOpt_defaultContext
	FOR() antlr.TerminalNode
	TYPE_P() antlr.TerminalNode
	Typename() ITypenameContext
	USING() antlr.TerminalNode
	Name() INameContext
	Opt_opfamily() IOpt_opfamilyContext
	AS() antlr.TerminalNode
	Opclass_item_list() IOpclass_item_listContext

	// IsCreateopclassstmtContext differentiates from other interfaces.
	IsCreateopclassstmtContext()
}

type CreateopclassstmtContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyCreateopclassstmtContext() *CreateopclassstmtContext {
	var p = new(CreateopclassstmtContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_createopclassstmt
	return p
}

func InitEmptyCreateopclassstmtContext(p *CreateopclassstmtContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_createopclassstmt
}

func (*CreateopclassstmtContext) IsCreateopclassstmtContext() {}

func NewCreateopclassstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CreateopclassstmtContext {
	var p = new(CreateopclassstmtContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_createopclassstmt

	return p
}

func (s *CreateopclassstmtContext) GetParser() antlr.Parser { return s.parser }

func (s *CreateopclassstmtContext) CREATE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCREATE, 0)
}

func (s *CreateopclassstmtContext) OPERATOR() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserOPERATOR, 0)
}

func (s *CreateopclassstmtContext) CLASS() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCLASS, 0)
}

func (s *CreateopclassstmtContext) Any_name() IAny_nameContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IAny_nameContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IAny_nameContext)
}

func (s *CreateopclassstmtContext) Opt_default() IOpt_defaultContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOpt_defaultContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOpt_defaultContext)
}

func (s *CreateopclassstmtContext) FOR() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserFOR, 0)
}

func (s *CreateopclassstmtContext) TYPE_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserTYPE_P, 0)
}

func (s *CreateopclassstmtContext) Typename() ITypenameContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ITypenameContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ITypenameContext)
}

func (s *CreateopclassstmtContext) USING() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserUSING, 0)
}

func (s *CreateopclassstmtContext) Name() INameContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(INameContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(INameContext)
}

func (s *CreateopclassstmtContext) Opt_opfamily() IOpt_opfamilyContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOpt_opfamilyContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOpt_opfamilyContext)
}

func (s *CreateopclassstmtContext) AS() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserAS, 0)
}

func (s *CreateopclassstmtContext) Opclass_item_list() IOpclass_item_listContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOpclass_item_listContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOpclass_item_listContext)
}

func (s *CreateopclassstmtContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *CreateopclassstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *CreateopclassstmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterCreateopclassstmt(s)
	}
}

func (s *CreateopclassstmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitCreateopclassstmt(s)
	}
}

func (s *CreateopclassstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitCreateopclassstmt(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Createopclassstmt() (localctx ICreateopclassstmtContext) {
	localctx = NewCreateopclassstmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 482, PostgreSQLParserRULE_createopclassstmt)
	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(4325)
		p.Match(PostgreSQLParserCREATE)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(4326)
		p.Match(PostgreSQLParserOPERATOR)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(4327)
		p.Match(PostgreSQLParserCLASS)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(4328)
		p.Any_name()
	}
	{
		p.SetState(4329)
		p.Opt_default()
	}
	{
		p.SetState(4330)
		p.Match(PostgreSQLParserFOR)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(4331)
		p.Match(PostgreSQLParserTYPE_P)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(4332)
		p.Typename()
	}
	{
		p.SetState(4333)
		p.Match(PostgreSQLParserUSING)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(4334)
		p.Name()
	}
	{
		p.SetState(4335)
		p.Opt_opfamily()
	}
	{
		p.SetState(4336)
		p.Match(PostgreSQLParserAS)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(4337)
		p.Opclass_item_list()
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IOpclass_item_listContext is an interface to support dynamic dispatch.
type IOpclass_item_listContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	AllOpclass_item() []IOpclass_itemContext
	Opclass_item(i int) IOpclass_itemContext
	AllCOMMA() []antlr.TerminalNode
	COMMA(i int) antlr.TerminalNode

	// IsOpclass_item_listContext differentiates from other interfaces.
	IsOpclass_item_listContext()
}

type Opclass_item_listContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyOpclass_item_listContext() *Opclass_item_listContext {
	var p = new(Opclass_item_listContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opclass_item_list
	return p
}

func InitEmptyOpclass_item_listContext(p *Opclass_item_listContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opclass_item_list
}

func (*Opclass_item_listContext) IsOpclass_item_listContext() {}

func NewOpclass_item_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opclass_item_listContext {
	var p = new(Opclass_item_listContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_opclass_item_list

	return p
}

func (s *Opclass_item_listContext) GetParser() antlr.Parser { return s.parser }

func (s *Opclass_item_listContext) AllOpclass_item() []IOpclass_itemContext {
	children := s.GetChildren()
	len := 0
	for _, ctx := range children {
		if _, ok := ctx.(IOpclass_itemContext); ok {
			len++
		}
	}

	tst := make([]IOpclass_itemContext, len)
	i := 0
	for _, ctx := range children {
		if t, ok := ctx.(IOpclass_itemContext); ok {
			tst[i] = t.(IOpclass_itemContext)
			i++
		}
	}

	return tst
}

func (s *Opclass_item_listContext) Opclass_item(i int) IOpclass_itemContext {
	var t antlr.RuleContext
	j := 0
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOpclass_itemContext); ok {
			if j == i {
				t = ctx.(antlr.RuleContext)
				break
			}
			j++
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOpclass_itemContext)
}

func (s *Opclass_item_listContext) AllCOMMA() []antlr.TerminalNode {
	return s.GetTokens(PostgreSQLParserCOMMA)
}

func (s *Opclass_item_listContext) COMMA(i int) antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCOMMA, i)
}

func (s *Opclass_item_listContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Opclass_item_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Opclass_item_listContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterOpclass_item_list(s)
	}
}

func (s *Opclass_item_listContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitOpclass_item_list(s)
	}
}

func (s *Opclass_item_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitOpclass_item_list(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Opclass_item_list() (localctx IOpclass_item_listContext) {
	localctx = NewOpclass_item_listContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 484, PostgreSQLParserRULE_opclass_item_list)
	var _la int

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(4339)
		p.Opclass_item()
	}
	p.SetState(4344)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}
	_la = p.GetTokenStream().LA(1)

	for _la == PostgreSQLParserCOMMA {
		{
			p.SetState(4340)
			p.Match(PostgreSQLParserCOMMA)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4341)
			p.Opclass_item()
		}

		p.SetState(4346)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}
		_la = p.GetTokenStream().LA(1)
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IOpclass_itemContext is an interface to support dynamic dispatch.
type IOpclass_itemContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	OPERATOR() antlr.TerminalNode
	Iconst() IIconstContext
	Any_operator() IAny_operatorContext
	Opclass_purpose() IOpclass_purposeContext
	Opt_recheck() IOpt_recheckContext
	Operator_with_argtypes() IOperator_with_argtypesContext
	FUNCTION() antlr.TerminalNode
	Function_with_argtypes() IFunction_with_argtypesContext
	OPEN_PAREN() antlr.TerminalNode
	Type_list() IType_listContext
	CLOSE_PAREN() antlr.TerminalNode
	STORAGE() antlr.TerminalNode
	Typename() ITypenameContext

	// IsOpclass_itemContext differentiates from other interfaces.
	IsOpclass_itemContext()
}

type Opclass_itemContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyOpclass_itemContext() *Opclass_itemContext {
	var p = new(Opclass_itemContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opclass_item
	return p
}

func InitEmptyOpclass_itemContext(p *Opclass_itemContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opclass_item
}

func (*Opclass_itemContext) IsOpclass_itemContext() {}

func NewOpclass_itemContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opclass_itemContext {
	var p = new(Opclass_itemContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_opclass_item

	return p
}

func (s *Opclass_itemContext) GetParser() antlr.Parser { return s.parser }

func (s *Opclass_itemContext) OPERATOR() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserOPERATOR, 0)
}

func (s *Opclass_itemContext) Iconst() IIconstContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IIconstContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IIconstContext)
}

func (s *Opclass_itemContext) Any_operator() IAny_operatorContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IAny_operatorContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IAny_operatorContext)
}

func (s *Opclass_itemContext) Opclass_purpose() IOpclass_purposeContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOpclass_purposeContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOpclass_purposeContext)
}

func (s *Opclass_itemContext) Opt_recheck() IOpt_recheckContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOpt_recheckContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOpt_recheckContext)
}

func (s *Opclass_itemContext) Operator_with_argtypes() IOperator_with_argtypesContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOperator_with_argtypesContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOperator_with_argtypesContext)
}

func (s *Opclass_itemContext) FUNCTION() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserFUNCTION, 0)
}

func (s *Opclass_itemContext) Function_with_argtypes() IFunction_with_argtypesContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IFunction_with_argtypesContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IFunction_with_argtypesContext)
}

func (s *Opclass_itemContext) OPEN_PAREN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserOPEN_PAREN, 0)
}

func (s *Opclass_itemContext) Type_list() IType_listContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IType_listContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IType_listContext)
}

func (s *Opclass_itemContext) CLOSE_PAREN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCLOSE_PAREN, 0)
}

func (s *Opclass_itemContext) STORAGE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserSTORAGE, 0)
}

func (s *Opclass_itemContext) Typename() ITypenameContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ITypenameContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ITypenameContext)
}

func (s *Opclass_itemContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Opclass_itemContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Opclass_itemContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterOpclass_item(s)
	}
}

func (s *Opclass_itemContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitOpclass_item(s)
	}
}

func (s *Opclass_itemContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitOpclass_item(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Opclass_item() (localctx IOpclass_itemContext) {
	localctx = NewOpclass_itemContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 486, PostgreSQLParserRULE_opclass_item)
	p.SetState(4372)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 208, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(4347)
			p.Match(PostgreSQLParserOPERATOR)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4348)
			p.Iconst()
		}
		{
			p.SetState(4349)
			p.Any_operator()
		}
		{
			p.SetState(4350)
			p.Opclass_purpose()
		}
		{
			p.SetState(4351)
			p.Opt_recheck()
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(4353)
			p.Match(PostgreSQLParserOPERATOR)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4354)
			p.Iconst()
		}
		{
			p.SetState(4355)
			p.Operator_with_argtypes()
		}
		{
			p.SetState(4356)
			p.Opclass_purpose()
		}
		{
			p.SetState(4357)
			p.Opt_recheck()
		}

	case 3:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(4359)
			p.Match(PostgreSQLParserFUNCTION)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4360)
			p.Iconst()
		}
		{
			p.SetState(4361)
			p.Function_with_argtypes()
		}

	case 4:
		p.EnterOuterAlt(localctx, 4)
		{
			p.SetState(4363)
			p.Match(PostgreSQLParserFUNCTION)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4364)
			p.Iconst()
		}
		{
			p.SetState(4365)
			p.Match(PostgreSQLParserOPEN_PAREN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4366)
			p.Type_list()
		}
		{
			p.SetState(4367)
			p.Match(PostgreSQLParserCLOSE_PAREN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4368)
			p.Function_with_argtypes()
		}

	case 5:
		p.EnterOuterAlt(localctx, 5)
		{
			p.SetState(4370)
			p.Match(PostgreSQLParserSTORAGE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4371)
			p.Typename()
		}

	case antlr.ATNInvalidAltNumber:
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IOpt_defaultContext is an interface to support dynamic dispatch.
type IOpt_defaultContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	DEFAULT() antlr.TerminalNode

	// IsOpt_defaultContext differentiates from other interfaces.
	IsOpt_defaultContext()
}

type Opt_defaultContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyOpt_defaultContext() *Opt_defaultContext {
	var p = new(Opt_defaultContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opt_default
	return p
}

func InitEmptyOpt_defaultContext(p *Opt_defaultContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opt_default
}

func (*Opt_defaultContext) IsOpt_defaultContext() {}

func NewOpt_defaultContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_defaultContext {
	var p = new(Opt_defaultContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_opt_default

	return p
}

func (s *Opt_defaultContext) GetParser() antlr.Parser { return s.parser }

func (s *Opt_defaultContext) DEFAULT() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserDEFAULT, 0)
}

func (s *Opt_defaultContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Opt_defaultContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Opt_defaultContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterOpt_default(s)
	}
}

func (s *Opt_defaultContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitOpt_default(s)
	}
}

func (s *Opt_defaultContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitOpt_default(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Opt_default() (localctx IOpt_defaultContext) {
	localctx = NewOpt_defaultContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 488, PostgreSQLParserRULE_opt_default)
	p.SetState(4376)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetTokenStream().LA(1) {
	case PostgreSQLParserDEFAULT:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(4374)
			p.Match(PostgreSQLParserDEFAULT)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case PostgreSQLParserFOR, PostgreSQLParserCONVERSION_P:
		p.EnterOuterAlt(localctx, 2)

	default:
		p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IOpt_opfamilyContext is an interface to support dynamic dispatch.
type IOpt_opfamilyContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	FAMILY() antlr.TerminalNode
	Any_name() IAny_nameContext

	// IsOpt_opfamilyContext differentiates from other interfaces.
	IsOpt_opfamilyContext()
}

type Opt_opfamilyContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyOpt_opfamilyContext() *Opt_opfamilyContext {
	var p = new(Opt_opfamilyContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opt_opfamily
	return p
}

func InitEmptyOpt_opfamilyContext(p *Opt_opfamilyContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opt_opfamily
}

func (*Opt_opfamilyContext) IsOpt_opfamilyContext() {}

func NewOpt_opfamilyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_opfamilyContext {
	var p = new(Opt_opfamilyContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_opt_opfamily

	return p
}

func (s *Opt_opfamilyContext) GetParser() antlr.Parser { return s.parser }

func (s *Opt_opfamilyContext) FAMILY() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserFAMILY, 0)
}

func (s *Opt_opfamilyContext) Any_name() IAny_nameContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IAny_nameContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IAny_nameContext)
}

func (s *Opt_opfamilyContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Opt_opfamilyContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Opt_opfamilyContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterOpt_opfamily(s)
	}
}

func (s *Opt_opfamilyContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitOpt_opfamily(s)
	}
}

func (s *Opt_opfamilyContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitOpt_opfamily(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Opt_opfamily() (localctx IOpt_opfamilyContext) {
	localctx = NewOpt_opfamilyContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 490, PostgreSQLParserRULE_opt_opfamily)
	p.SetState(4381)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetTokenStream().LA(1) {
	case PostgreSQLParserFAMILY:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(4378)
			p.Match(PostgreSQLParserFAMILY)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4379)
			p.Any_name()
		}

	case PostgreSQLParserAS:
		p.EnterOuterAlt(localctx, 2)

	default:
		p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IOpclass_purposeContext is an interface to support dynamic dispatch.
type IOpclass_purposeContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	FOR() antlr.TerminalNode
	SEARCH() antlr.TerminalNode
	ORDER() antlr.TerminalNode
	BY() antlr.TerminalNode
	Any_name() IAny_nameContext

	// IsOpclass_purposeContext differentiates from other interfaces.
	IsOpclass_purposeContext()
}

type Opclass_purposeContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyOpclass_purposeContext() *Opclass_purposeContext {
	var p = new(Opclass_purposeContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opclass_purpose
	return p
}

func InitEmptyOpclass_purposeContext(p *Opclass_purposeContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opclass_purpose
}

func (*Opclass_purposeContext) IsOpclass_purposeContext() {}

func NewOpclass_purposeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opclass_purposeContext {
	var p = new(Opclass_purposeContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_opclass_purpose

	return p
}

func (s *Opclass_purposeContext) GetParser() antlr.Parser { return s.parser }

func (s *Opclass_purposeContext) FOR() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserFOR, 0)
}

func (s *Opclass_purposeContext) SEARCH() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserSEARCH, 0)
}

func (s *Opclass_purposeContext) ORDER() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserORDER, 0)
}

func (s *Opclass_purposeContext) BY() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserBY, 0)
}

func (s *Opclass_purposeContext) Any_name() IAny_nameContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IAny_nameContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IAny_nameContext)
}

func (s *Opclass_purposeContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Opclass_purposeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Opclass_purposeContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterOpclass_purpose(s)
	}
}

func (s *Opclass_purposeContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitOpclass_purpose(s)
	}
}

func (s *Opclass_purposeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitOpclass_purpose(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Opclass_purpose() (localctx IOpclass_purposeContext) {
	localctx = NewOpclass_purposeContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 492, PostgreSQLParserRULE_opclass_purpose)
	p.SetState(4390)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 211, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(4383)
			p.Match(PostgreSQLParserFOR)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4384)
			p.Match(PostgreSQLParserSEARCH)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(4385)
			p.Match(PostgreSQLParserFOR)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4386)
			p.Match(PostgreSQLParserORDER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4387)
			p.Match(PostgreSQLParserBY)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4388)
			p.Any_name()
		}

	case 3:
		p.EnterOuterAlt(localctx, 3)

	case antlr.ATNInvalidAltNumber:
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IOpt_recheckContext is an interface to support dynamic dispatch.
type IOpt_recheckContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	RECHECK() antlr.TerminalNode

	// IsOpt_recheckContext differentiates from other interfaces.
	IsOpt_recheckContext()
}

type Opt_recheckContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyOpt_recheckContext() *Opt_recheckContext {
	var p = new(Opt_recheckContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opt_recheck
	return p
}

func InitEmptyOpt_recheckContext(p *Opt_recheckContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opt_recheck
}

func (*Opt_recheckContext) IsOpt_recheckContext() {}

func NewOpt_recheckContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_recheckContext {
	var p = new(Opt_recheckContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_opt_recheck

	return p
}

func (s *Opt_recheckContext) GetParser() antlr.Parser { return s.parser }

func (s *Opt_recheckContext) RECHECK() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserRECHECK, 0)
}

func (s *Opt_recheckContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Opt_recheckContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Opt_recheckContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterOpt_recheck(s)
	}
}

func (s *Opt_recheckContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitOpt_recheck(s)
	}
}

func (s *Opt_recheckContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitOpt_recheck(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Opt_recheck() (localctx IOpt_recheckContext) {
	localctx = NewOpt_recheckContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 494, PostgreSQLParserRULE_opt_recheck)
	p.SetState(4394)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetTokenStream().LA(1) {
	case PostgreSQLParserRECHECK:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(4392)
			p.Match(PostgreSQLParserRECHECK)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case PostgreSQLParserEOF, PostgreSQLParserOPEN_PAREN, PostgreSQLParserCOMMA, PostgreSQLParserSEMI, PostgreSQLParserANALYSE, PostgreSQLParserANALYZE, PostgreSQLParserCREATE, PostgreSQLParserDO, PostgreSQLParserFETCH, PostgreSQLParserGRANT, PostgreSQLParserINTO, PostgreSQLParserSELECT, PostgreSQLParserTABLE, PostgreSQLParserWITH, PostgreSQLParserABORT_P, PostgreSQLParserALTER, PostgreSQLParserBEGIN_P, PostgreSQLParserCHECKPOINT, PostgreSQLParserCLOSE, PostgreSQLParserCLUSTER, PostgreSQLParserCOMMENT, PostgreSQLParserCOMMIT, PostgreSQLParserCOPY, PostgreSQLParserDEALLOCATE, PostgreSQLParserDECLARE, PostgreSQLParserDELETE_P, PostgreSQLParserDISCARD, PostgreSQLParserDROP, PostgreSQLParserEXECUTE, PostgreSQLParserEXPLAIN, PostgreSQLParserINSERT, PostgreSQLParserLISTEN, PostgreSQLParserLOAD, PostgreSQLParserLOCK_P, PostgreSQLParserMERGE, PostgreSQLParserMOVE, PostgreSQLParserNOTIFY, PostgreSQLParserPREPARE, PostgreSQLParserREASSIGN, PostgreSQLParserREFRESH, PostgreSQLParserREINDEX, PostgreSQLParserRELEASE, PostgreSQLParserRESET, PostgreSQLParserREVOKE, PostgreSQLParserROLLBACK, PostgreSQLParserSAVEPOINT, PostgreSQLParserSECURITY, PostgreSQLParserSET, PostgreSQLParserSHOW, PostgreSQLParserSTART, PostgreSQLParserTRUNCATE, PostgreSQLParserUNLISTEN, PostgreSQLParserUPDATE, PostgreSQLParserVACUUM, PostgreSQLParserVALUES, PostgreSQLParserCALL, PostgreSQLParserIMPORT_P, PostgreSQLParserEND_P, PostgreSQLParserMetaCommand:
		p.EnterOuterAlt(localctx, 2)

	default:
		p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// ICreateopfamilystmtContext is an interface to support dynamic dispatch.
type ICreateopfamilystmtContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	CREATE() antlr.TerminalNode
	OPERATOR() antlr.TerminalNode
	FAMILY() antlr.TerminalNode
	Any_name() IAny_nameContext
	USING() antlr.TerminalNode
	Name() INameContext

	// IsCreateopfamilystmtContext differentiates from other interfaces.
	IsCreateopfamilystmtContext()
}

type CreateopfamilystmtContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyCreateopfamilystmtContext() *CreateopfamilystmtContext {
	var p = new(CreateopfamilystmtContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_createopfamilystmt
	return p
}

func InitEmptyCreateopfamilystmtContext(p *CreateopfamilystmtContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_createopfamilystmt
}

func (*CreateopfamilystmtContext) IsCreateopfamilystmtContext() {}

func NewCreateopfamilystmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CreateopfamilystmtContext {
	var p = new(CreateopfamilystmtContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_createopfamilystmt

	return p
}

func (s *CreateopfamilystmtContext) GetParser() antlr.Parser { return s.parser }

func (s *CreateopfamilystmtContext) CREATE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCREATE, 0)
}

func (s *CreateopfamilystmtContext) OPERATOR() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserOPERATOR, 0)
}

func (s *CreateopfamilystmtContext) FAMILY() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserFAMILY, 0)
}

func (s *CreateopfamilystmtContext) Any_name() IAny_nameContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IAny_nameContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IAny_nameContext)
}

func (s *CreateopfamilystmtContext) USING() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserUSING, 0)
}

func (s *CreateopfamilystmtContext) Name() INameContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(INameContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(INameContext)
}

func (s *CreateopfamilystmtContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *CreateopfamilystmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *CreateopfamilystmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterCreateopfamilystmt(s)
	}
}

func (s *CreateopfamilystmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitCreateopfamilystmt(s)
	}
}

func (s *CreateopfamilystmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitCreateopfamilystmt(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Createopfamilystmt() (localctx ICreateopfamilystmtContext) {
	localctx = NewCreateopfamilystmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 496, PostgreSQLParserRULE_createopfamilystmt)
	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(4396)
		p.Match(PostgreSQLParserCREATE)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(4397)
		p.Match(PostgreSQLParserOPERATOR)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(4398)
		p.Match(PostgreSQLParserFAMILY)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(4399)
		p.Any_name()
	}
	{
		p.SetState(4400)
		p.Match(PostgreSQLParserUSING)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(4401)
		p.Name()
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IAlteropfamilystmtContext is an interface to support dynamic dispatch.
type IAlteropfamilystmtContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	ALTER() antlr.TerminalNode
	OPERATOR() antlr.TerminalNode
	FAMILY() antlr.TerminalNode
	Any_name() IAny_nameContext
	USING() antlr.TerminalNode
	Name() INameContext
	ADD_P() antlr.TerminalNode
	Opclass_item_list() IOpclass_item_listContext
	DROP() antlr.TerminalNode
	Opclass_drop_list() IOpclass_drop_listContext

	// IsAlteropfamilystmtContext differentiates from other interfaces.
	IsAlteropfamilystmtContext()
}

type AlteropfamilystmtContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyAlteropfamilystmtContext() *AlteropfamilystmtContext {
	var p = new(AlteropfamilystmtContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_alteropfamilystmt
	return p
}

func InitEmptyAlteropfamilystmtContext(p *AlteropfamilystmtContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_alteropfamilystmt
}

func (*AlteropfamilystmtContext) IsAlteropfamilystmtContext() {}

func NewAlteropfamilystmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AlteropfamilystmtContext {
	var p = new(AlteropfamilystmtContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_alteropfamilystmt

	return p
}

func (s *AlteropfamilystmtContext) GetParser() antlr.Parser { return s.parser }

func (s *AlteropfamilystmtContext) ALTER() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserALTER, 0)
}

func (s *AlteropfamilystmtContext) OPERATOR() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserOPERATOR, 0)
}

func (s *AlteropfamilystmtContext) FAMILY() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserFAMILY, 0)
}

func (s *AlteropfamilystmtContext) Any_name() IAny_nameContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IAny_nameContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IAny_nameContext)
}

func (s *AlteropfamilystmtContext) USING() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserUSING, 0)
}

func (s *AlteropfamilystmtContext) Name() INameContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(INameContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(INameContext)
}

func (s *AlteropfamilystmtContext) ADD_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserADD_P, 0)
}

func (s *AlteropfamilystmtContext) Opclass_item_list() IOpclass_item_listContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOpclass_item_listContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOpclass_item_listContext)
}

func (s *AlteropfamilystmtContext) DROP() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserDROP, 0)
}

func (s *AlteropfamilystmtContext) Opclass_drop_list() IOpclass_drop_listContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOpclass_drop_listContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOpclass_drop_listContext)
}

func (s *AlteropfamilystmtContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *AlteropfamilystmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *AlteropfamilystmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterAlteropfamilystmt(s)
	}
}

func (s *AlteropfamilystmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitAlteropfamilystmt(s)
	}
}

func (s *AlteropfamilystmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitAlteropfamilystmt(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Alteropfamilystmt() (localctx IAlteropfamilystmtContext) {
	localctx = NewAlteropfamilystmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 498, PostgreSQLParserRULE_alteropfamilystmt)
	p.SetState(4421)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 213, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(4403)
			p.Match(PostgreSQLParserALTER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4404)
			p.Match(PostgreSQLParserOPERATOR)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4405)
			p.Match(PostgreSQLParserFAMILY)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4406)
			p.Any_name()
		}
		{
			p.SetState(4407)
			p.Match(PostgreSQLParserUSING)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4408)
			p.Name()
		}
		{
			p.SetState(4409)
			p.Match(PostgreSQLParserADD_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4410)
			p.Opclass_item_list()
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(4412)
			p.Match(PostgreSQLParserALTER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4413)
			p.Match(PostgreSQLParserOPERATOR)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4414)
			p.Match(PostgreSQLParserFAMILY)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4415)
			p.Any_name()
		}
		{
			p.SetState(4416)
			p.Match(PostgreSQLParserUSING)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4417)
			p.Name()
		}
		{
			p.SetState(4418)
			p.Match(PostgreSQLParserDROP)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4419)
			p.Opclass_drop_list()
		}

	case antlr.ATNInvalidAltNumber:
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IOpclass_drop_listContext is an interface to support dynamic dispatch.
type IOpclass_drop_listContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	AllOpclass_drop() []IOpclass_dropContext
	Opclass_drop(i int) IOpclass_dropContext
	AllCOMMA() []antlr.TerminalNode
	COMMA(i int) antlr.TerminalNode

	// IsOpclass_drop_listContext differentiates from other interfaces.
	IsOpclass_drop_listContext()
}

type Opclass_drop_listContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyOpclass_drop_listContext() *Opclass_drop_listContext {
	var p = new(Opclass_drop_listContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opclass_drop_list
	return p
}

func InitEmptyOpclass_drop_listContext(p *Opclass_drop_listContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opclass_drop_list
}

func (*Opclass_drop_listContext) IsOpclass_drop_listContext() {}

func NewOpclass_drop_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opclass_drop_listContext {
	var p = new(Opclass_drop_listContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_opclass_drop_list

	return p
}

func (s *Opclass_drop_listContext) GetParser() antlr.Parser { return s.parser }

func (s *Opclass_drop_listContext) AllOpclass_drop() []IOpclass_dropContext {
	children := s.GetChildren()
	len := 0
	for _, ctx := range children {
		if _, ok := ctx.(IOpclass_dropContext); ok {
			len++
		}
	}

	tst := make([]IOpclass_dropContext, len)
	i := 0
	for _, ctx := range children {
		if t, ok := ctx.(IOpclass_dropContext); ok {
			tst[i] = t.(IOpclass_dropContext)
			i++
		}
	}

	return tst
}

func (s *Opclass_drop_listContext) Opclass_drop(i int) IOpclass_dropContext {
	var t antlr.RuleContext
	j := 0
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOpclass_dropContext); ok {
			if j == i {
				t = ctx.(antlr.RuleContext)
				break
			}
			j++
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOpclass_dropContext)
}

func (s *Opclass_drop_listContext) AllCOMMA() []antlr.TerminalNode {
	return s.GetTokens(PostgreSQLParserCOMMA)
}

func (s *Opclass_drop_listContext) COMMA(i int) antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCOMMA, i)
}

func (s *Opclass_drop_listContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Opclass_drop_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Opclass_drop_listContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterOpclass_drop_list(s)
	}
}

func (s *Opclass_drop_listContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitOpclass_drop_list(s)
	}
}

func (s *Opclass_drop_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitOpclass_drop_list(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Opclass_drop_list() (localctx IOpclass_drop_listContext) {
	localctx = NewOpclass_drop_listContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 500, PostgreSQLParserRULE_opclass_drop_list)
	var _la int

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(4423)
		p.Opclass_drop()
	}
	p.SetState(4428)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}
	_la = p.GetTokenStream().LA(1)

	for _la == PostgreSQLParserCOMMA {
		{
			p.SetState(4424)
			p.Match(PostgreSQLParserCOMMA)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4425)
			p.Opclass_drop()
		}

		p.SetState(4430)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}
		_la = p.GetTokenStream().LA(1)
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IOpclass_dropContext is an interface to support dynamic dispatch.
type IOpclass_dropContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	OPERATOR() antlr.TerminalNode
	Iconst() IIconstContext
	OPEN_PAREN() antlr.TerminalNode
	Type_list() IType_listContext
	CLOSE_PAREN() antlr.TerminalNode
	FUNCTION() antlr.TerminalNode

	// IsOpclass_dropContext differentiates from other interfaces.
	IsOpclass_dropContext()
}

type Opclass_dropContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyOpclass_dropContext() *Opclass_dropContext {
	var p = new(Opclass_dropContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opclass_drop
	return p
}

func InitEmptyOpclass_dropContext(p *Opclass_dropContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opclass_drop
}

func (*Opclass_dropContext) IsOpclass_dropContext() {}

func NewOpclass_dropContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opclass_dropContext {
	var p = new(Opclass_dropContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_opclass_drop

	return p
}

func (s *Opclass_dropContext) GetParser() antlr.Parser { return s.parser }

func (s *Opclass_dropContext) OPERATOR() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserOPERATOR, 0)
}

func (s *Opclass_dropContext) Iconst() IIconstContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IIconstContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IIconstContext)
}

func (s *Opclass_dropContext) OPEN_PAREN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserOPEN_PAREN, 0)
}

func (s *Opclass_dropContext) Type_list() IType_listContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IType_listContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IType_listContext)
}

func (s *Opclass_dropContext) CLOSE_PAREN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCLOSE_PAREN, 0)
}

func (s *Opclass_dropContext) FUNCTION() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserFUNCTION, 0)
}

func (s *Opclass_dropContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Opclass_dropContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Opclass_dropContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterOpclass_drop(s)
	}
}

func (s *Opclass_dropContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitOpclass_drop(s)
	}
}

func (s *Opclass_dropContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitOpclass_drop(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Opclass_drop() (localctx IOpclass_dropContext) {
	localctx = NewOpclass_dropContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 502, PostgreSQLParserRULE_opclass_drop)
	p.SetState(4443)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetTokenStream().LA(1) {
	case PostgreSQLParserOPERATOR:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(4431)
			p.Match(PostgreSQLParserOPERATOR)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4432)
			p.Iconst()
		}
		{
			p.SetState(4433)
			p.Match(PostgreSQLParserOPEN_PAREN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4434)
			p.Type_list()
		}
		{
			p.SetState(4435)
			p.Match(PostgreSQLParserCLOSE_PAREN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case PostgreSQLParserFUNCTION:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(4437)
			p.Match(PostgreSQLParserFUNCTION)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4438)
			p.Iconst()
		}
		{
			p.SetState(4439)
			p.Match(PostgreSQLParserOPEN_PAREN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4440)
			p.Type_list()
		}
		{
			p.SetState(4441)
			p.Match(PostgreSQLParserCLOSE_PAREN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	default:
		p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IDropopclassstmtContext is an interface to support dynamic dispatch.
type IDropopclassstmtContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	DROP() antlr.TerminalNode
	OPERATOR() antlr.TerminalNode
	CLASS() antlr.TerminalNode
	Any_name() IAny_nameContext
	USING() antlr.TerminalNode
	Name() INameContext
	Opt_drop_behavior() IOpt_drop_behaviorContext
	IF_P() antlr.TerminalNode
	EXISTS() antlr.TerminalNode

	// IsDropopclassstmtContext differentiates from other interfaces.
	IsDropopclassstmtContext()
}

type DropopclassstmtContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyDropopclassstmtContext() *DropopclassstmtContext {
	var p = new(DropopclassstmtContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_dropopclassstmt
	return p
}

func InitEmptyDropopclassstmtContext(p *DropopclassstmtContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_dropopclassstmt
}

func (*DropopclassstmtContext) IsDropopclassstmtContext() {}

func NewDropopclassstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DropopclassstmtContext {
	var p = new(DropopclassstmtContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_dropopclassstmt

	return p
}

func (s *DropopclassstmtContext) GetParser() antlr.Parser { return s.parser }

func (s *DropopclassstmtContext) DROP() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserDROP, 0)
}

func (s *DropopclassstmtContext) OPERATOR() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserOPERATOR, 0)
}

func (s *DropopclassstmtContext) CLASS() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCLASS, 0)
}

func (s *DropopclassstmtContext) Any_name() IAny_nameContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IAny_nameContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IAny_nameContext)
}

func (s *DropopclassstmtContext) USING() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserUSING, 0)
}

func (s *DropopclassstmtContext) Name() INameContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(INameContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(INameContext)
}

func (s *DropopclassstmtContext) Opt_drop_behavior() IOpt_drop_behaviorContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOpt_drop_behaviorContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOpt_drop_behaviorContext)
}

func (s *DropopclassstmtContext) IF_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserIF_P, 0)
}

func (s *DropopclassstmtContext) EXISTS() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserEXISTS, 0)
}

func (s *DropopclassstmtContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *DropopclassstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *DropopclassstmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterDropopclassstmt(s)
	}
}

func (s *DropopclassstmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitDropopclassstmt(s)
	}
}

func (s *DropopclassstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitDropopclassstmt(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Dropopclassstmt() (localctx IDropopclassstmtContext) {
	localctx = NewDropopclassstmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 504, PostgreSQLParserRULE_dropopclassstmt)
	p.SetState(4463)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 216, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(4445)
			p.Match(PostgreSQLParserDROP)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4446)
			p.Match(PostgreSQLParserOPERATOR)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4447)
			p.Match(PostgreSQLParserCLASS)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4448)
			p.Any_name()
		}
		{
			p.SetState(4449)
			p.Match(PostgreSQLParserUSING)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4450)
			p.Name()
		}
		{
			p.SetState(4451)
			p.Opt_drop_behavior()
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(4453)
			p.Match(PostgreSQLParserDROP)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4454)
			p.Match(PostgreSQLParserOPERATOR)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4455)
			p.Match(PostgreSQLParserCLASS)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4456)
			p.Match(PostgreSQLParserIF_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4457)
			p.Match(PostgreSQLParserEXISTS)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4458)
			p.Any_name()
		}
		{
			p.SetState(4459)
			p.Match(PostgreSQLParserUSING)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4460)
			p.Name()
		}
		{
			p.SetState(4461)
			p.Opt_drop_behavior()
		}

	case antlr.ATNInvalidAltNumber:
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IDropopfamilystmtContext is an interface to support dynamic dispatch.
type IDropopfamilystmtContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	DROP() antlr.TerminalNode
	OPERATOR() antlr.TerminalNode
	FAMILY() antlr.TerminalNode
	Any_name() IAny_nameContext
	USING() antlr.TerminalNode
	Name() INameContext
	Opt_drop_behavior() IOpt_drop_behaviorContext
	IF_P() antlr.TerminalNode
	EXISTS() antlr.TerminalNode

	// IsDropopfamilystmtContext differentiates from other interfaces.
	IsDropopfamilystmtContext()
}

type DropopfamilystmtContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyDropopfamilystmtContext() *DropopfamilystmtContext {
	var p = new(DropopfamilystmtContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_dropopfamilystmt
	return p
}

func InitEmptyDropopfamilystmtContext(p *DropopfamilystmtContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_dropopfamilystmt
}

func (*DropopfamilystmtContext) IsDropopfamilystmtContext() {}

func NewDropopfamilystmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DropopfamilystmtContext {
	var p = new(DropopfamilystmtContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_dropopfamilystmt

	return p
}

func (s *DropopfamilystmtContext) GetParser() antlr.Parser { return s.parser }

func (s *DropopfamilystmtContext) DROP() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserDROP, 0)
}

func (s *DropopfamilystmtContext) OPERATOR() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserOPERATOR, 0)
}

func (s *DropopfamilystmtContext) FAMILY() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserFAMILY, 0)
}

func (s *DropopfamilystmtContext) Any_name() IAny_nameContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IAny_nameContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IAny_nameContext)
}

func (s *DropopfamilystmtContext) USING() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserUSING, 0)
}

func (s *DropopfamilystmtContext) Name() INameContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(INameContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(INameContext)
}

func (s *DropopfamilystmtContext) Opt_drop_behavior() IOpt_drop_behaviorContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOpt_drop_behaviorContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOpt_drop_behaviorContext)
}

func (s *DropopfamilystmtContext) IF_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserIF_P, 0)
}

func (s *DropopfamilystmtContext) EXISTS() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserEXISTS, 0)
}

func (s *DropopfamilystmtContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *DropopfamilystmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *DropopfamilystmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterDropopfamilystmt(s)
	}
}

func (s *DropopfamilystmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitDropopfamilystmt(s)
	}
}

func (s *DropopfamilystmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitDropopfamilystmt(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Dropopfamilystmt() (localctx IDropopfamilystmtContext) {
	localctx = NewDropopfamilystmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 506, PostgreSQLParserRULE_dropopfamilystmt)
	p.SetState(4483)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 217, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(4465)
			p.Match(PostgreSQLParserDROP)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4466)
			p.Match(PostgreSQLParserOPERATOR)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4467)
			p.Match(PostgreSQLParserFAMILY)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4468)
			p.Any_name()
		}
		{
			p.SetState(4469)
			p.Match(PostgreSQLParserUSING)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4470)
			p.Name()
		}
		{
			p.SetState(4471)
			p.Opt_drop_behavior()
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(4473)
			p.Match(PostgreSQLParserDROP)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4474)
			p.Match(PostgreSQLParserOPERATOR)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4475)
			p.Match(PostgreSQLParserFAMILY)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4476)
			p.Match(PostgreSQLParserIF_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4477)
			p.Match(PostgreSQLParserEXISTS)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4478)
			p.Any_name()
		}
		{
			p.SetState(4479)
			p.Match(PostgreSQLParserUSING)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4480)
			p.Name()
		}
		{
			p.SetState(4481)
			p.Opt_drop_behavior()
		}

	case antlr.ATNInvalidAltNumber:
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IDropownedstmtContext is an interface to support dynamic dispatch.
type IDropownedstmtContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	DROP() antlr.TerminalNode
	OWNED() antlr.TerminalNode
	BY() antlr.TerminalNode
	Role_list() IRole_listContext
	Opt_drop_behavior() IOpt_drop_behaviorContext

	// IsDropownedstmtContext differentiates from other interfaces.
	IsDropownedstmtContext()
}

type DropownedstmtContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyDropownedstmtContext() *DropownedstmtContext {
	var p = new(DropownedstmtContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_dropownedstmt
	return p
}

func InitEmptyDropownedstmtContext(p *DropownedstmtContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_dropownedstmt
}

func (*DropownedstmtContext) IsDropownedstmtContext() {}

func NewDropownedstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DropownedstmtContext {
	var p = new(DropownedstmtContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_dropownedstmt

	return p
}

func (s *DropownedstmtContext) GetParser() antlr.Parser { return s.parser }

func (s *DropownedstmtContext) DROP() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserDROP, 0)
}

func (s *DropownedstmtContext) OWNED() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserOWNED, 0)
}

func (s *DropownedstmtContext) BY() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserBY, 0)
}

func (s *DropownedstmtContext) Role_list() IRole_listContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IRole_listContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IRole_listContext)
}

func (s *DropownedstmtContext) Opt_drop_behavior() IOpt_drop_behaviorContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOpt_drop_behaviorContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOpt_drop_behaviorContext)
}

func (s *DropownedstmtContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *DropownedstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *DropownedstmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterDropownedstmt(s)
	}
}

func (s *DropownedstmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitDropownedstmt(s)
	}
}

func (s *DropownedstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitDropownedstmt(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Dropownedstmt() (localctx IDropownedstmtContext) {
	localctx = NewDropownedstmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 508, PostgreSQLParserRULE_dropownedstmt)
	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(4485)
		p.Match(PostgreSQLParserDROP)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(4486)
		p.Match(PostgreSQLParserOWNED)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(4487)
		p.Match(PostgreSQLParserBY)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(4488)
		p.Role_list()
	}
	{
		p.SetState(4489)
		p.Opt_drop_behavior()
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IReassignownedstmtContext is an interface to support dynamic dispatch.
type IReassignownedstmtContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	REASSIGN() antlr.TerminalNode
	OWNED() antlr.TerminalNode
	BY() antlr.TerminalNode
	Role_list() IRole_listContext
	TO() antlr.TerminalNode
	Rolespec() IRolespecContext

	// IsReassignownedstmtContext differentiates from other interfaces.
	IsReassignownedstmtContext()
}

type ReassignownedstmtContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyReassignownedstmtContext() *ReassignownedstmtContext {
	var p = new(ReassignownedstmtContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_reassignownedstmt
	return p
}

func InitEmptyReassignownedstmtContext(p *ReassignownedstmtContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_reassignownedstmt
}

func (*ReassignownedstmtContext) IsReassignownedstmtContext() {}

func NewReassignownedstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ReassignownedstmtContext {
	var p = new(ReassignownedstmtContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_reassignownedstmt

	return p
}

func (s *ReassignownedstmtContext) GetParser() antlr.Parser { return s.parser }

func (s *ReassignownedstmtContext) REASSIGN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserREASSIGN, 0)
}

func (s *ReassignownedstmtContext) OWNED() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserOWNED, 0)
}

func (s *ReassignownedstmtContext) BY() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserBY, 0)
}

func (s *ReassignownedstmtContext) Role_list() IRole_listContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IRole_listContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IRole_listContext)
}

func (s *ReassignownedstmtContext) TO() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserTO, 0)
}

func (s *ReassignownedstmtContext) Rolespec() IRolespecContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IRolespecContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IRolespecContext)
}

func (s *ReassignownedstmtContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *ReassignownedstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *ReassignownedstmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterReassignownedstmt(s)
	}
}

func (s *ReassignownedstmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitReassignownedstmt(s)
	}
}

func (s *ReassignownedstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitReassignownedstmt(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Reassignownedstmt() (localctx IReassignownedstmtContext) {
	localctx = NewReassignownedstmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 510, PostgreSQLParserRULE_reassignownedstmt)
	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(4491)
		p.Match(PostgreSQLParserREASSIGN)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(4492)
		p.Match(PostgreSQLParserOWNED)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(4493)
		p.Match(PostgreSQLParserBY)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(4494)
		p.Role_list()
	}
	{
		p.SetState(4495)
		p.Match(PostgreSQLParserTO)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(4496)
		p.Rolespec()
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IDropstmtContext is an interface to support dynamic dispatch.
type IDropstmtContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	DROP() antlr.TerminalNode
	Object_type_any_name() IObject_type_any_nameContext
	IF_P() antlr.TerminalNode
	EXISTS() antlr.TerminalNode
	Any_name_list() IAny_name_listContext
	Opt_drop_behavior() IOpt_drop_behaviorContext
	Drop_type_name() IDrop_type_nameContext
	Name_list() IName_listContext
	Object_type_name_on_any_name() IObject_type_name_on_any_nameContext
	Name() INameContext
	ON() antlr.TerminalNode
	Any_name() IAny_nameContext
	TYPE_P() antlr.TerminalNode
	Type_name_list() IType_name_listContext
	DOMAIN_P() antlr.TerminalNode
	INDEX() antlr.TerminalNode
	CONCURRENTLY() antlr.TerminalNode

	// IsDropstmtContext differentiates from other interfaces.
	IsDropstmtContext()
}

type DropstmtContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyDropstmtContext() *DropstmtContext {
	var p = new(DropstmtContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_dropstmt
	return p
}

func InitEmptyDropstmtContext(p *DropstmtContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_dropstmt
}

func (*DropstmtContext) IsDropstmtContext() {}

func NewDropstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DropstmtContext {
	var p = new(DropstmtContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_dropstmt

	return p
}

func (s *DropstmtContext) GetParser() antlr.Parser { return s.parser }

func (s *DropstmtContext) DROP() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserDROP, 0)
}

func (s *DropstmtContext) Object_type_any_name() IObject_type_any_nameContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IObject_type_any_nameContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IObject_type_any_nameContext)
}

func (s *DropstmtContext) IF_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserIF_P, 0)
}

func (s *DropstmtContext) EXISTS() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserEXISTS, 0)
}

func (s *DropstmtContext) Any_name_list() IAny_name_listContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IAny_name_listContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IAny_name_listContext)
}

func (s *DropstmtContext) Opt_drop_behavior() IOpt_drop_behaviorContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOpt_drop_behaviorContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOpt_drop_behaviorContext)
}

func (s *DropstmtContext) Drop_type_name() IDrop_type_nameContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IDrop_type_nameContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IDrop_type_nameContext)
}

func (s *DropstmtContext) Name_list() IName_listContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IName_listContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IName_listContext)
}

func (s *DropstmtContext) Object_type_name_on_any_name() IObject_type_name_on_any_nameContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IObject_type_name_on_any_nameContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IObject_type_name_on_any_nameContext)
}

func (s *DropstmtContext) Name() INameContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(INameContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(INameContext)
}

func (s *DropstmtContext) ON() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserON, 0)
}

func (s *DropstmtContext) Any_name() IAny_nameContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IAny_nameContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IAny_nameContext)
}

func (s *DropstmtContext) TYPE_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserTYPE_P, 0)
}

func (s *DropstmtContext) Type_name_list() IType_name_listContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IType_name_listContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IType_name_listContext)
}

func (s *DropstmtContext) DOMAIN_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserDOMAIN_P, 0)
}

func (s *DropstmtContext) INDEX() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserINDEX, 0)
}

func (s *DropstmtContext) CONCURRENTLY() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCONCURRENTLY, 0)
}

func (s *DropstmtContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *DropstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *DropstmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterDropstmt(s)
	}
}

func (s *DropstmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitDropstmt(s)
	}
}

func (s *DropstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitDropstmt(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Dropstmt() (localctx IDropstmtContext) {
	localctx = NewDropstmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 512, PostgreSQLParserRULE_dropstmt)
	p.SetState(4576)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 218, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(4498)
			p.Match(PostgreSQLParserDROP)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4499)
			p.Object_type_any_name()
		}
		{
			p.SetState(4500)
			p.Match(PostgreSQLParserIF_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4501)
			p.Match(PostgreSQLParserEXISTS)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4502)
			p.Any_name_list()
		}
		{
			p.SetState(4503)
			p.Opt_drop_behavior()
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(4505)
			p.Match(PostgreSQLParserDROP)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4506)
			p.Object_type_any_name()
		}
		{
			p.SetState(4507)
			p.Any_name_list()
		}
		{
			p.SetState(4508)
			p.Opt_drop_behavior()
		}

	case 3:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(4510)
			p.Match(PostgreSQLParserDROP)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4511)
			p.Drop_type_name()
		}
		{
			p.SetState(4512)
			p.Match(PostgreSQLParserIF_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4513)
			p.Match(PostgreSQLParserEXISTS)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4514)
			p.Name_list()
		}
		{
			p.SetState(4515)
			p.Opt_drop_behavior()
		}

	case 4:
		p.EnterOuterAlt(localctx, 4)
		{
			p.SetState(4517)
			p.Match(PostgreSQLParserDROP)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4518)
			p.Drop_type_name()
		}
		{
			p.SetState(4519)
			p.Name_list()
		}
		{
			p.SetState(4520)
			p.Opt_drop_behavior()
		}

	case 5:
		p.EnterOuterAlt(localctx, 5)
		{
			p.SetState(4522)
			p.Match(PostgreSQLParserDROP)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4523)
			p.Object_type_name_on_any_name()
		}
		{
			p.SetState(4524)
			p.Name()
		}
		{
			p.SetState(4525)
			p.Match(PostgreSQLParserON)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4526)
			p.Any_name()
		}
		{
			p.SetState(4527)
			p.Opt_drop_behavior()
		}

	case 6:
		p.EnterOuterAlt(localctx, 6)
		{
			p.SetState(4529)
			p.Match(PostgreSQLParserDROP)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4530)
			p.Object_type_name_on_any_name()
		}
		{
			p.SetState(4531)
			p.Match(PostgreSQLParserIF_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4532)
			p.Match(PostgreSQLParserEXISTS)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4533)
			p.Name()
		}
		{
			p.SetState(4534)
			p.Match(PostgreSQLParserON)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4535)
			p.Any_name()
		}
		{
			p.SetState(4536)
			p.Opt_drop_behavior()
		}

	case 7:
		p.EnterOuterAlt(localctx, 7)
		{
			p.SetState(4538)
			p.Match(PostgreSQLParserDROP)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4539)
			p.Match(PostgreSQLParserTYPE_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4540)
			p.Type_name_list()
		}
		{
			p.SetState(4541)
			p.Opt_drop_behavior()
		}

	case 8:
		p.EnterOuterAlt(localctx, 8)
		{
			p.SetState(4543)
			p.Match(PostgreSQLParserDROP)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4544)
			p.Match(PostgreSQLParserTYPE_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4545)
			p.Match(PostgreSQLParserIF_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4546)
			p.Match(PostgreSQLParserEXISTS)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4547)
			p.Type_name_list()
		}
		{
			p.SetState(4548)
			p.Opt_drop_behavior()
		}

	case 9:
		p.EnterOuterAlt(localctx, 9)
		{
			p.SetState(4550)
			p.Match(PostgreSQLParserDROP)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4551)
			p.Match(PostgreSQLParserDOMAIN_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4552)
			p.Type_name_list()
		}
		{
			p.SetState(4553)
			p.Opt_drop_behavior()
		}

	case 10:
		p.EnterOuterAlt(localctx, 10)
		{
			p.SetState(4555)
			p.Match(PostgreSQLParserDROP)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4556)
			p.Match(PostgreSQLParserDOMAIN_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4557)
			p.Match(PostgreSQLParserIF_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4558)
			p.Match(PostgreSQLParserEXISTS)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4559)
			p.Type_name_list()
		}
		{
			p.SetState(4560)
			p.Opt_drop_behavior()
		}

	case 11:
		p.EnterOuterAlt(localctx, 11)
		{
			p.SetState(4562)
			p.Match(PostgreSQLParserDROP)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4563)
			p.Match(PostgreSQLParserINDEX)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4564)
			p.Match(PostgreSQLParserCONCURRENTLY)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4565)
			p.Any_name_list()
		}
		{
			p.SetState(4566)
			p.Opt_drop_behavior()
		}

	case 12:
		p.EnterOuterAlt(localctx, 12)
		{
			p.SetState(4568)
			p.Match(PostgreSQLParserDROP)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4569)
			p.Match(PostgreSQLParserINDEX)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4570)
			p.Match(PostgreSQLParserCONCURRENTLY)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4571)
			p.Match(PostgreSQLParserIF_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4572)
			p.Match(PostgreSQLParserEXISTS)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4573)
			p.Any_name_list()
		}
		{
			p.SetState(4574)
			p.Opt_drop_behavior()
		}

	case antlr.ATNInvalidAltNumber:
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IObject_type_any_nameContext is an interface to support dynamic dispatch.
type IObject_type_any_nameContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	TABLE() antlr.TerminalNode
	SEQUENCE() antlr.TerminalNode
	VIEW() antlr.TerminalNode
	MATERIALIZED() antlr.TerminalNode
	INDEX() antlr.TerminalNode
	FOREIGN() antlr.TerminalNode
	COLLATION() antlr.TerminalNode
	CONVERSION_P() antlr.TerminalNode
	STATISTICS() antlr.TerminalNode
	TEXT_P() antlr.TerminalNode
	SEARCH() antlr.TerminalNode
	PARSER() antlr.TerminalNode
	DICTIONARY() antlr.TerminalNode
	TEMPLATE() antlr.TerminalNode
	CONFIGURATION() antlr.TerminalNode

	// IsObject_type_any_nameContext differentiates from other interfaces.
	IsObject_type_any_nameContext()
}

type Object_type_any_nameContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyObject_type_any_nameContext() *Object_type_any_nameContext {
	var p = new(Object_type_any_nameContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_object_type_any_name
	return p
}

func InitEmptyObject_type_any_nameContext(p *Object_type_any_nameContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_object_type_any_name
}

func (*Object_type_any_nameContext) IsObject_type_any_nameContext() {}

func NewObject_type_any_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Object_type_any_nameContext {
	var p = new(Object_type_any_nameContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_object_type_any_name

	return p
}

func (s *Object_type_any_nameContext) GetParser() antlr.Parser { return s.parser }

func (s *Object_type_any_nameContext) TABLE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserTABLE, 0)
}

func (s *Object_type_any_nameContext) SEQUENCE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserSEQUENCE, 0)
}

func (s *Object_type_any_nameContext) VIEW() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserVIEW, 0)
}

func (s *Object_type_any_nameContext) MATERIALIZED() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserMATERIALIZED, 0)
}

func (s *Object_type_any_nameContext) INDEX() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserINDEX, 0)
}

func (s *Object_type_any_nameContext) FOREIGN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserFOREIGN, 0)
}

func (s *Object_type_any_nameContext) COLLATION() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCOLLATION, 0)
}

func (s *Object_type_any_nameContext) CONVERSION_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCONVERSION_P, 0)
}

func (s *Object_type_any_nameContext) STATISTICS() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserSTATISTICS, 0)
}

func (s *Object_type_any_nameContext) TEXT_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserTEXT_P, 0)
}

func (s *Object_type_any_nameContext) SEARCH() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserSEARCH, 0)
}

func (s *Object_type_any_nameContext) PARSER() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserPARSER, 0)
}

func (s *Object_type_any_nameContext) DICTIONARY() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserDICTIONARY, 0)
}

func (s *Object_type_any_nameContext) TEMPLATE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserTEMPLATE, 0)
}

func (s *Object_type_any_nameContext) CONFIGURATION() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCONFIGURATION, 0)
}

func (s *Object_type_any_nameContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Object_type_any_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Object_type_any_nameContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterObject_type_any_name(s)
	}
}

func (s *Object_type_any_nameContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitObject_type_any_name(s)
	}
}

func (s *Object_type_any_nameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitObject_type_any_name(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Object_type_any_name() (localctx IObject_type_any_nameContext) {
	localctx = NewObject_type_any_nameContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 514, PostgreSQLParserRULE_object_type_any_name)
	p.SetState(4601)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 219, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(4578)
			p.Match(PostgreSQLParserTABLE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(4579)
			p.Match(PostgreSQLParserSEQUENCE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 3:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(4580)
			p.Match(PostgreSQLParserVIEW)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 4:
		p.EnterOuterAlt(localctx, 4)
		{
			p.SetState(4581)
			p.Match(PostgreSQLParserMATERIALIZED)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4582)
			p.Match(PostgreSQLParserVIEW)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 5:
		p.EnterOuterAlt(localctx, 5)
		{
			p.SetState(4583)
			p.Match(PostgreSQLParserINDEX)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 6:
		p.EnterOuterAlt(localctx, 6)
		{
			p.SetState(4584)
			p.Match(PostgreSQLParserFOREIGN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4585)
			p.Match(PostgreSQLParserTABLE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 7:
		p.EnterOuterAlt(localctx, 7)
		{
			p.SetState(4586)
			p.Match(PostgreSQLParserCOLLATION)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 8:
		p.EnterOuterAlt(localctx, 8)
		{
			p.SetState(4587)
			p.Match(PostgreSQLParserCONVERSION_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 9:
		p.EnterOuterAlt(localctx, 9)
		{
			p.SetState(4588)
			p.Match(PostgreSQLParserSTATISTICS)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 10:
		p.EnterOuterAlt(localctx, 10)
		{
			p.SetState(4589)
			p.Match(PostgreSQLParserTEXT_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4590)
			p.Match(PostgreSQLParserSEARCH)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4591)
			p.Match(PostgreSQLParserPARSER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 11:
		p.EnterOuterAlt(localctx, 11)
		{
			p.SetState(4592)
			p.Match(PostgreSQLParserTEXT_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4593)
			p.Match(PostgreSQLParserSEARCH)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4594)
			p.Match(PostgreSQLParserDICTIONARY)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 12:
		p.EnterOuterAlt(localctx, 12)
		{
			p.SetState(4595)
			p.Match(PostgreSQLParserTEXT_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4596)
			p.Match(PostgreSQLParserSEARCH)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4597)
			p.Match(PostgreSQLParserTEMPLATE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 13:
		p.EnterOuterAlt(localctx, 13)
		{
			p.SetState(4598)
			p.Match(PostgreSQLParserTEXT_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4599)
			p.Match(PostgreSQLParserSEARCH)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4600)
			p.Match(PostgreSQLParserCONFIGURATION)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case antlr.ATNInvalidAltNumber:
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IObject_type_nameContext is an interface to support dynamic dispatch.
type IObject_type_nameContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Drop_type_name() IDrop_type_nameContext
	DATABASE() antlr.TerminalNode
	ROLE() antlr.TerminalNode
	SUBSCRIPTION() antlr.TerminalNode
	TABLESPACE() antlr.TerminalNode

	// IsObject_type_nameContext differentiates from other interfaces.
	IsObject_type_nameContext()
}

type Object_type_nameContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyObject_type_nameContext() *Object_type_nameContext {
	var p = new(Object_type_nameContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_object_type_name
	return p
}

func InitEmptyObject_type_nameContext(p *Object_type_nameContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_object_type_name
}

func (*Object_type_nameContext) IsObject_type_nameContext() {}

func NewObject_type_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Object_type_nameContext {
	var p = new(Object_type_nameContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_object_type_name

	return p
}

func (s *Object_type_nameContext) GetParser() antlr.Parser { return s.parser }

func (s *Object_type_nameContext) Drop_type_name() IDrop_type_nameContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IDrop_type_nameContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IDrop_type_nameContext)
}

func (s *Object_type_nameContext) DATABASE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserDATABASE, 0)
}

func (s *Object_type_nameContext) ROLE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserROLE, 0)
}

func (s *Object_type_nameContext) SUBSCRIPTION() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserSUBSCRIPTION, 0)
}

func (s *Object_type_nameContext) TABLESPACE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserTABLESPACE, 0)
}

func (s *Object_type_nameContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Object_type_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Object_type_nameContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterObject_type_name(s)
	}
}

func (s *Object_type_nameContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitObject_type_name(s)
	}
}

func (s *Object_type_nameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitObject_type_name(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Object_type_name() (localctx IObject_type_nameContext) {
	localctx = NewObject_type_nameContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 516, PostgreSQLParserRULE_object_type_name)
	p.SetState(4608)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetTokenStream().LA(1) {
	case PostgreSQLParserFOREIGN, PostgreSQLParserACCESS, PostgreSQLParserEVENT, PostgreSQLParserEXTENSION, PostgreSQLParserLANGUAGE, PostgreSQLParserPROCEDURAL, PostgreSQLParserSCHEMA, PostgreSQLParserSERVER, PostgreSQLParserPUBLICATION:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(4603)
			p.Drop_type_name()
		}

	case PostgreSQLParserDATABASE:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(4604)
			p.Match(PostgreSQLParserDATABASE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case PostgreSQLParserROLE:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(4605)
			p.Match(PostgreSQLParserROLE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case PostgreSQLParserSUBSCRIPTION:
		p.EnterOuterAlt(localctx, 4)
		{
			p.SetState(4606)
			p.Match(PostgreSQLParserSUBSCRIPTION)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case PostgreSQLParserTABLESPACE:
		p.EnterOuterAlt(localctx, 5)
		{
			p.SetState(4607)
			p.Match(PostgreSQLParserTABLESPACE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	default:
		p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IDrop_type_nameContext is an interface to support dynamic dispatch.
type IDrop_type_nameContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	ACCESS() antlr.TerminalNode
	METHOD() antlr.TerminalNode
	EVENT() antlr.TerminalNode
	TRIGGER() antlr.TerminalNode
	EXTENSION() antlr.TerminalNode
	FOREIGN() antlr.TerminalNode
	DATA_P() antlr.TerminalNode
	WRAPPER() antlr.TerminalNode
	Opt_procedural() IOpt_proceduralContext
	LANGUAGE() antlr.TerminalNode
	PUBLICATION() antlr.TerminalNode
	SCHEMA() antlr.TerminalNode
	SERVER() antlr.TerminalNode

	// IsDrop_type_nameContext differentiates from other interfaces.
	IsDrop_type_nameContext()
}

type Drop_type_nameContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyDrop_type_nameContext() *Drop_type_nameContext {
	var p = new(Drop_type_nameContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_drop_type_name
	return p
}

func InitEmptyDrop_type_nameContext(p *Drop_type_nameContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_drop_type_name
}

func (*Drop_type_nameContext) IsDrop_type_nameContext() {}

func NewDrop_type_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_type_nameContext {
	var p = new(Drop_type_nameContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_drop_type_name

	return p
}

func (s *Drop_type_nameContext) GetParser() antlr.Parser { return s.parser }

func (s *Drop_type_nameContext) ACCESS() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserACCESS, 0)
}

func (s *Drop_type_nameContext) METHOD() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserMETHOD, 0)
}

func (s *Drop_type_nameContext) EVENT() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserEVENT, 0)
}

func (s *Drop_type_nameContext) TRIGGER() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserTRIGGER, 0)
}

func (s *Drop_type_nameContext) EXTENSION() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserEXTENSION, 0)
}

func (s *Drop_type_nameContext) FOREIGN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserFOREIGN, 0)
}

func (s *Drop_type_nameContext) DATA_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserDATA_P, 0)
}

func (s *Drop_type_nameContext) WRAPPER() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserWRAPPER, 0)
}

func (s *Drop_type_nameContext) Opt_procedural() IOpt_proceduralContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOpt_proceduralContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOpt_proceduralContext)
}

func (s *Drop_type_nameContext) LANGUAGE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserLANGUAGE, 0)
}

func (s *Drop_type_nameContext) PUBLICATION() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserPUBLICATION, 0)
}

func (s *Drop_type_nameContext) SCHEMA() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserSCHEMA, 0)
}

func (s *Drop_type_nameContext) SERVER() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserSERVER, 0)
}

func (s *Drop_type_nameContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Drop_type_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Drop_type_nameContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterDrop_type_name(s)
	}
}

func (s *Drop_type_nameContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitDrop_type_name(s)
	}
}

func (s *Drop_type_nameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitDrop_type_name(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Drop_type_name() (localctx IDrop_type_nameContext) {
	localctx = NewDrop_type_nameContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 518, PostgreSQLParserRULE_drop_type_name)
	p.SetState(4624)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetTokenStream().LA(1) {
	case PostgreSQLParserACCESS:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(4610)
			p.Match(PostgreSQLParserACCESS)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4611)
			p.Match(PostgreSQLParserMETHOD)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case PostgreSQLParserEVENT:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(4612)
			p.Match(PostgreSQLParserEVENT)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4613)
			p.Match(PostgreSQLParserTRIGGER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case PostgreSQLParserEXTENSION:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(4614)
			p.Match(PostgreSQLParserEXTENSION)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case PostgreSQLParserFOREIGN:
		p.EnterOuterAlt(localctx, 4)
		{
			p.SetState(4615)
			p.Match(PostgreSQLParserFOREIGN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4616)
			p.Match(PostgreSQLParserDATA_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4617)
			p.Match(PostgreSQLParserWRAPPER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case PostgreSQLParserLANGUAGE, PostgreSQLParserPROCEDURAL:
		p.EnterOuterAlt(localctx, 5)
		{
			p.SetState(4618)
			p.Opt_procedural()
		}
		{
			p.SetState(4619)
			p.Match(PostgreSQLParserLANGUAGE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case PostgreSQLParserPUBLICATION:
		p.EnterOuterAlt(localctx, 6)
		{
			p.SetState(4621)
			p.Match(PostgreSQLParserPUBLICATION)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case PostgreSQLParserSCHEMA:
		p.EnterOuterAlt(localctx, 7)
		{
			p.SetState(4622)
			p.Match(PostgreSQLParserSCHEMA)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case PostgreSQLParserSERVER:
		p.EnterOuterAlt(localctx, 8)
		{
			p.SetState(4623)
			p.Match(PostgreSQLParserSERVER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	default:
		p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IObject_type_name_on_any_nameContext is an interface to support dynamic dispatch.
type IObject_type_name_on_any_nameContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	POLICY() antlr.TerminalNode
	RULE() antlr.TerminalNode
	TRIGGER() antlr.TerminalNode

	// IsObject_type_name_on_any_nameContext differentiates from other interfaces.
	IsObject_type_name_on_any_nameContext()
}

type Object_type_name_on_any_nameContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyObject_type_name_on_any_nameContext() *Object_type_name_on_any_nameContext {
	var p = new(Object_type_name_on_any_nameContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_object_type_name_on_any_name
	return p
}

func InitEmptyObject_type_name_on_any_nameContext(p *Object_type_name_on_any_nameContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_object_type_name_on_any_name
}

func (*Object_type_name_on_any_nameContext) IsObject_type_name_on_any_nameContext() {}

func NewObject_type_name_on_any_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Object_type_name_on_any_nameContext {
	var p = new(Object_type_name_on_any_nameContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_object_type_name_on_any_name

	return p
}

func (s *Object_type_name_on_any_nameContext) GetParser() antlr.Parser { return s.parser }

func (s *Object_type_name_on_any_nameContext) POLICY() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserPOLICY, 0)
}

func (s *Object_type_name_on_any_nameContext) RULE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserRULE, 0)
}

func (s *Object_type_name_on_any_nameContext) TRIGGER() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserTRIGGER, 0)
}

func (s *Object_type_name_on_any_nameContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Object_type_name_on_any_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Object_type_name_on_any_nameContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterObject_type_name_on_any_name(s)
	}
}

func (s *Object_type_name_on_any_nameContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitObject_type_name_on_any_name(s)
	}
}

func (s *Object_type_name_on_any_nameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitObject_type_name_on_any_name(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Object_type_name_on_any_name() (localctx IObject_type_name_on_any_nameContext) {
	localctx = NewObject_type_name_on_any_nameContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 520, PostgreSQLParserRULE_object_type_name_on_any_name)
	var _la int

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(4626)
		_la = p.GetTokenStream().LA(1)

		if !(_la == PostgreSQLParserRULE || _la == PostgreSQLParserTRIGGER || _la == PostgreSQLParserPOLICY) {
			p.GetErrorHandler().RecoverInline(p)
		} else {
			p.GetErrorHandler().ReportMatch(p)
			p.Consume()
		}
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IAny_name_listContext is an interface to support dynamic dispatch.
type IAny_name_listContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	AllAny_name() []IAny_nameContext
	Any_name(i int) IAny_nameContext
	AllCOMMA() []antlr.TerminalNode
	COMMA(i int) antlr.TerminalNode

	// IsAny_name_listContext differentiates from other interfaces.
	IsAny_name_listContext()
}

type Any_name_listContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyAny_name_listContext() *Any_name_listContext {
	var p = new(Any_name_listContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_any_name_list
	return p
}

func InitEmptyAny_name_listContext(p *Any_name_listContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_any_name_list
}

func (*Any_name_listContext) IsAny_name_listContext() {}

func NewAny_name_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Any_name_listContext {
	var p = new(Any_name_listContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_any_name_list

	return p
}

func (s *Any_name_listContext) GetParser() antlr.Parser { return s.parser }

func (s *Any_name_listContext) AllAny_name() []IAny_nameContext {
	children := s.GetChildren()
	len := 0
	for _, ctx := range children {
		if _, ok := ctx.(IAny_nameContext); ok {
			len++
		}
	}

	tst := make([]IAny_nameContext, len)
	i := 0
	for _, ctx := range children {
		if t, ok := ctx.(IAny_nameContext); ok {
			tst[i] = t.(IAny_nameContext)
			i++
		}
	}

	return tst
}

func (s *Any_name_listContext) Any_name(i int) IAny_nameContext {
	var t antlr.RuleContext
	j := 0
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IAny_nameContext); ok {
			if j == i {
				t = ctx.(antlr.RuleContext)
				break
			}
			j++
		}
	}

	if t == nil {
		return nil
	}

	return t.(IAny_nameContext)
}

func (s *Any_name_listContext) AllCOMMA() []antlr.TerminalNode {
	return s.GetTokens(PostgreSQLParserCOMMA)
}

func (s *Any_name_listContext) COMMA(i int) antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCOMMA, i)
}

func (s *Any_name_listContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Any_name_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Any_name_listContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterAny_name_list(s)
	}
}

func (s *Any_name_listContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitAny_name_list(s)
	}
}

func (s *Any_name_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitAny_name_list(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Any_name_list() (localctx IAny_name_listContext) {
	localctx = NewAny_name_listContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 522, PostgreSQLParserRULE_any_name_list)
	var _la int

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(4628)
		p.Any_name()
	}
	p.SetState(4633)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}
	_la = p.GetTokenStream().LA(1)

	for _la == PostgreSQLParserCOMMA {
		{
			p.SetState(4629)
			p.Match(PostgreSQLParserCOMMA)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4630)
			p.Any_name()
		}

		p.SetState(4635)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}
		_la = p.GetTokenStream().LA(1)
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IAny_nameContext is an interface to support dynamic dispatch.
type IAny_nameContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Colid() IColidContext
	Attrs() IAttrsContext

	// IsAny_nameContext differentiates from other interfaces.
	IsAny_nameContext()
}

type Any_nameContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyAny_nameContext() *Any_nameContext {
	var p = new(Any_nameContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_any_name
	return p
}

func InitEmptyAny_nameContext(p *Any_nameContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_any_name
}

func (*Any_nameContext) IsAny_nameContext() {}

func NewAny_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Any_nameContext {
	var p = new(Any_nameContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_any_name

	return p
}

func (s *Any_nameContext) GetParser() antlr.Parser { return s.parser }

func (s *Any_nameContext) Colid() IColidContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IColidContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IColidContext)
}

func (s *Any_nameContext) Attrs() IAttrsContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IAttrsContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IAttrsContext)
}

func (s *Any_nameContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Any_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Any_nameContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterAny_name(s)
	}
}

func (s *Any_nameContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitAny_name(s)
	}
}

func (s *Any_nameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitAny_name(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Any_name() (localctx IAny_nameContext) {
	localctx = NewAny_nameContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 524, PostgreSQLParserRULE_any_name)
	var _la int

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(4636)
		p.Colid()
	}
	p.SetState(4638)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}
	_la = p.GetTokenStream().LA(1)

	if _la == PostgreSQLParserDOT {
		{
			p.SetState(4637)
			p.Attrs()
		}

	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IAttrsContext is an interface to support dynamic dispatch.
type IAttrsContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	AllDOT() []antlr.TerminalNode
	DOT(i int) antlr.TerminalNode
	AllAttr_name() []IAttr_nameContext
	Attr_name(i int) IAttr_nameContext

	// IsAttrsContext differentiates from other interfaces.
	IsAttrsContext()
}

type AttrsContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyAttrsContext() *AttrsContext {
	var p = new(AttrsContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_attrs
	return p
}

func InitEmptyAttrsContext(p *AttrsContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_attrs
}

func (*AttrsContext) IsAttrsContext() {}

func NewAttrsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AttrsContext {
	var p = new(AttrsContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_attrs

	return p
}

func (s *AttrsContext) GetParser() antlr.Parser { return s.parser }

func (s *AttrsContext) AllDOT() []antlr.TerminalNode {
	return s.GetTokens(PostgreSQLParserDOT)
}

func (s *AttrsContext) DOT(i int) antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserDOT, i)
}

func (s *AttrsContext) AllAttr_name() []IAttr_nameContext {
	children := s.GetChildren()
	len := 0
	for _, ctx := range children {
		if _, ok := ctx.(IAttr_nameContext); ok {
			len++
		}
	}

	tst := make([]IAttr_nameContext, len)
	i := 0
	for _, ctx := range children {
		if t, ok := ctx.(IAttr_nameContext); ok {
			tst[i] = t.(IAttr_nameContext)
			i++
		}
	}

	return tst
}

func (s *AttrsContext) Attr_name(i int) IAttr_nameContext {
	var t antlr.RuleContext
	j := 0
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IAttr_nameContext); ok {
			if j == i {
				t = ctx.(antlr.RuleContext)
				break
			}
			j++
		}
	}

	if t == nil {
		return nil
	}

	return t.(IAttr_nameContext)
}

func (s *AttrsContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *AttrsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *AttrsContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterAttrs(s)
	}
}

func (s *AttrsContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitAttrs(s)
	}
}

func (s *AttrsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitAttrs(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Attrs() (localctx IAttrsContext) {
	localctx = NewAttrsContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 526, PostgreSQLParserRULE_attrs)
	var _alt int

	p.EnterOuterAlt(localctx, 1)
	p.SetState(4642)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}
	_alt = 1
	for ok := true; ok; ok = _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
		switch _alt {
		case 1:
			{
				p.SetState(4640)
				p.Match(PostgreSQLParserDOT)
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}
			{
				p.SetState(4641)
				p.Attr_name()
			}

		default:
			p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
			goto errorExit
		}

		p.SetState(4644)
		p.GetErrorHandler().Sync(p)
		_alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 224, p.GetParserRuleContext())
		if p.HasError() {
			goto errorExit
		}
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IType_name_listContext is an interface to support dynamic dispatch.
type IType_name_listContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	AllTypename() []ITypenameContext
	Typename(i int) ITypenameContext
	AllCOMMA() []antlr.TerminalNode
	COMMA(i int) antlr.TerminalNode

	// IsType_name_listContext differentiates from other interfaces.
	IsType_name_listContext()
}

type Type_name_listContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyType_name_listContext() *Type_name_listContext {
	var p = new(Type_name_listContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_type_name_list
	return p
}

func InitEmptyType_name_listContext(p *Type_name_listContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_type_name_list
}

func (*Type_name_listContext) IsType_name_listContext() {}

func NewType_name_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Type_name_listContext {
	var p = new(Type_name_listContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_type_name_list

	return p
}

func (s *Type_name_listContext) GetParser() antlr.Parser { return s.parser }

func (s *Type_name_listContext) AllTypename() []ITypenameContext {
	children := s.GetChildren()
	len := 0
	for _, ctx := range children {
		if _, ok := ctx.(ITypenameContext); ok {
			len++
		}
	}

	tst := make([]ITypenameContext, len)
	i := 0
	for _, ctx := range children {
		if t, ok := ctx.(ITypenameContext); ok {
			tst[i] = t.(ITypenameContext)
			i++
		}
	}

	return tst
}

func (s *Type_name_listContext) Typename(i int) ITypenameContext {
	var t antlr.RuleContext
	j := 0
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ITypenameContext); ok {
			if j == i {
				t = ctx.(antlr.RuleContext)
				break
			}
			j++
		}
	}

	if t == nil {
		return nil
	}

	return t.(ITypenameContext)
}

func (s *Type_name_listContext) AllCOMMA() []antlr.TerminalNode {
	return s.GetTokens(PostgreSQLParserCOMMA)
}

func (s *Type_name_listContext) COMMA(i int) antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCOMMA, i)
}

func (s *Type_name_listContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Type_name_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Type_name_listContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterType_name_list(s)
	}
}

func (s *Type_name_listContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitType_name_list(s)
	}
}

func (s *Type_name_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitType_name_list(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Type_name_list() (localctx IType_name_listContext) {
	localctx = NewType_name_listContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 528, PostgreSQLParserRULE_type_name_list)
	var _la int

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(4646)
		p.Typename()
	}
	p.SetState(4651)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}
	_la = p.GetTokenStream().LA(1)

	for _la == PostgreSQLParserCOMMA {
		{
			p.SetState(4647)
			p.Match(PostgreSQLParserCOMMA)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4648)
			p.Typename()
		}

		p.SetState(4653)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}
		_la = p.GetTokenStream().LA(1)
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// ITruncatestmtContext is an interface to support dynamic dispatch.
type ITruncatestmtContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	TRUNCATE() antlr.TerminalNode
	Opt_table() IOpt_tableContext
	Relation_expr_list() IRelation_expr_listContext
	Opt_restart_seqs() IOpt_restart_seqsContext
	Opt_drop_behavior() IOpt_drop_behaviorContext

	// IsTruncatestmtContext differentiates from other interfaces.
	IsTruncatestmtContext()
}

type TruncatestmtContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyTruncatestmtContext() *TruncatestmtContext {
	var p = new(TruncatestmtContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_truncatestmt
	return p
}

func InitEmptyTruncatestmtContext(p *TruncatestmtContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_truncatestmt
}

func (*TruncatestmtContext) IsTruncatestmtContext() {}

func NewTruncatestmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TruncatestmtContext {
	var p = new(TruncatestmtContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_truncatestmt

	return p
}

func (s *TruncatestmtContext) GetParser() antlr.Parser { return s.parser }

func (s *TruncatestmtContext) TRUNCATE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserTRUNCATE, 0)
}

func (s *TruncatestmtContext) Opt_table() IOpt_tableContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOpt_tableContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOpt_tableContext)
}

func (s *TruncatestmtContext) Relation_expr_list() IRelation_expr_listContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IRelation_expr_listContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IRelation_expr_listContext)
}

func (s *TruncatestmtContext) Opt_restart_seqs() IOpt_restart_seqsContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOpt_restart_seqsContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOpt_restart_seqsContext)
}

func (s *TruncatestmtContext) Opt_drop_behavior() IOpt_drop_behaviorContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOpt_drop_behaviorContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOpt_drop_behaviorContext)
}

func (s *TruncatestmtContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *TruncatestmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *TruncatestmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterTruncatestmt(s)
	}
}

func (s *TruncatestmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitTruncatestmt(s)
	}
}

func (s *TruncatestmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitTruncatestmt(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Truncatestmt() (localctx ITruncatestmtContext) {
	localctx = NewTruncatestmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 530, PostgreSQLParserRULE_truncatestmt)
	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(4654)
		p.Match(PostgreSQLParserTRUNCATE)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(4655)
		p.Opt_table()
	}
	{
		p.SetState(4656)
		p.Relation_expr_list()
	}
	{
		p.SetState(4657)
		p.Opt_restart_seqs()
	}
	{
		p.SetState(4658)
		p.Opt_drop_behavior()
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IOpt_restart_seqsContext is an interface to support dynamic dispatch.
type IOpt_restart_seqsContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	CONTINUE_P() antlr.TerminalNode
	IDENTITY_P() antlr.TerminalNode
	RESTART() antlr.TerminalNode

	// IsOpt_restart_seqsContext differentiates from other interfaces.
	IsOpt_restart_seqsContext()
}

type Opt_restart_seqsContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyOpt_restart_seqsContext() *Opt_restart_seqsContext {
	var p = new(Opt_restart_seqsContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opt_restart_seqs
	return p
}

func InitEmptyOpt_restart_seqsContext(p *Opt_restart_seqsContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opt_restart_seqs
}

func (*Opt_restart_seqsContext) IsOpt_restart_seqsContext() {}

func NewOpt_restart_seqsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_restart_seqsContext {
	var p = new(Opt_restart_seqsContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_opt_restart_seqs

	return p
}

func (s *Opt_restart_seqsContext) GetParser() antlr.Parser { return s.parser }

func (s *Opt_restart_seqsContext) CONTINUE_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCONTINUE_P, 0)
}

func (s *Opt_restart_seqsContext) IDENTITY_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserIDENTITY_P, 0)
}

func (s *Opt_restart_seqsContext) RESTART() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserRESTART, 0)
}

func (s *Opt_restart_seqsContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Opt_restart_seqsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Opt_restart_seqsContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterOpt_restart_seqs(s)
	}
}

func (s *Opt_restart_seqsContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitOpt_restart_seqs(s)
	}
}

func (s *Opt_restart_seqsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitOpt_restart_seqs(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Opt_restart_seqs() (localctx IOpt_restart_seqsContext) {
	localctx = NewOpt_restart_seqsContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 532, PostgreSQLParserRULE_opt_restart_seqs)
	p.SetState(4665)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetTokenStream().LA(1) {
	case PostgreSQLParserCONTINUE_P:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(4660)
			p.Match(PostgreSQLParserCONTINUE_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4661)
			p.Match(PostgreSQLParserIDENTITY_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case PostgreSQLParserRESTART:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(4662)
			p.Match(PostgreSQLParserRESTART)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4663)
			p.Match(PostgreSQLParserIDENTITY_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case PostgreSQLParserEOF, PostgreSQLParserOPEN_PAREN, PostgreSQLParserSEMI, PostgreSQLParserANALYSE, PostgreSQLParserANALYZE, PostgreSQLParserCREATE, PostgreSQLParserDO, PostgreSQLParserFETCH, PostgreSQLParserGRANT, PostgreSQLParserINTO, PostgreSQLParserSELECT, PostgreSQLParserTABLE, PostgreSQLParserWITH, PostgreSQLParserABORT_P, PostgreSQLParserALTER, PostgreSQLParserBEGIN_P, PostgreSQLParserCASCADE, PostgreSQLParserCHECKPOINT, PostgreSQLParserCLOSE, PostgreSQLParserCLUSTER, PostgreSQLParserCOMMENT, PostgreSQLParserCOMMIT, PostgreSQLParserCOPY, PostgreSQLParserDEALLOCATE, PostgreSQLParserDECLARE, PostgreSQLParserDELETE_P, PostgreSQLParserDISCARD, PostgreSQLParserDROP, PostgreSQLParserEXECUTE, PostgreSQLParserEXPLAIN, PostgreSQLParserINSERT, PostgreSQLParserLISTEN, PostgreSQLParserLOAD, PostgreSQLParserLOCK_P, PostgreSQLParserMERGE, PostgreSQLParserMOVE, PostgreSQLParserNOTIFY, PostgreSQLParserPREPARE, PostgreSQLParserREASSIGN, PostgreSQLParserREFRESH, PostgreSQLParserREINDEX, PostgreSQLParserRELEASE, PostgreSQLParserRESET, PostgreSQLParserRESTRICT, PostgreSQLParserREVOKE, PostgreSQLParserROLLBACK, PostgreSQLParserSAVEPOINT, PostgreSQLParserSECURITY, PostgreSQLParserSET, PostgreSQLParserSHOW, PostgreSQLParserSTART, PostgreSQLParserTRUNCATE, PostgreSQLParserUNLISTEN, PostgreSQLParserUPDATE, PostgreSQLParserVACUUM, PostgreSQLParserVALUES, PostgreSQLParserCALL, PostgreSQLParserIMPORT_P, PostgreSQLParserEND_P, PostgreSQLParserMetaCommand:
		p.EnterOuterAlt(localctx, 3)

	default:
		p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// ICommentstmtContext is an interface to support dynamic dispatch.
type ICommentstmtContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	COMMENT() antlr.TerminalNode
	AllON() []antlr.TerminalNode
	ON(i int) antlr.TerminalNode
	Object_type_any_name() IObject_type_any_nameContext
	Any_name() IAny_nameContext
	IS() antlr.TerminalNode
	Comment_text() IComment_textContext
	COLUMN() antlr.TerminalNode
	Object_type_name() IObject_type_nameContext
	Name() INameContext
	TYPE_P() antlr.TerminalNode
	AllTypename() []ITypenameContext
	Typename(i int) ITypenameContext
	DOMAIN_P() antlr.TerminalNode
	AGGREGATE() antlr.TerminalNode
	Aggregate_with_argtypes() IAggregate_with_argtypesContext
	FUNCTION() antlr.TerminalNode
	Function_with_argtypes() IFunction_with_argtypesContext
	OPERATOR() antlr.TerminalNode
	Operator_with_argtypes() IOperator_with_argtypesContext
	CONSTRAINT() antlr.TerminalNode
	Object_type_name_on_any_name() IObject_type_name_on_any_nameContext
	PROCEDURE() antlr.TerminalNode
	ROUTINE() antlr.TerminalNode
	TRANSFORM() antlr.TerminalNode
	FOR() antlr.TerminalNode
	LANGUAGE() antlr.TerminalNode
	CLASS() antlr.TerminalNode
	USING() antlr.TerminalNode
	FAMILY() antlr.TerminalNode
	LARGE_P() antlr.TerminalNode
	OBJECT_P() antlr.TerminalNode
	Numericonly() INumericonlyContext
	CAST() antlr.TerminalNode
	OPEN_PAREN() antlr.TerminalNode
	AS() antlr.TerminalNode
	CLOSE_PAREN() antlr.TerminalNode

	// IsCommentstmtContext differentiates from other interfaces.
	IsCommentstmtContext()
}

type CommentstmtContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyCommentstmtContext() *CommentstmtContext {
	var p = new(CommentstmtContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_commentstmt
	return p
}

func InitEmptyCommentstmtContext(p *CommentstmtContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_commentstmt
}

func (*CommentstmtContext) IsCommentstmtContext() {}

func NewCommentstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CommentstmtContext {
	var p = new(CommentstmtContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_commentstmt

	return p
}

func (s *CommentstmtContext) GetParser() antlr.Parser { return s.parser }

func (s *CommentstmtContext) COMMENT() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCOMMENT, 0)
}

func (s *CommentstmtContext) AllON() []antlr.TerminalNode {
	return s.GetTokens(PostgreSQLParserON)
}

func (s *CommentstmtContext) ON(i int) antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserON, i)
}

func (s *CommentstmtContext) Object_type_any_name() IObject_type_any_nameContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IObject_type_any_nameContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IObject_type_any_nameContext)
}

func (s *CommentstmtContext) Any_name() IAny_nameContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IAny_nameContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IAny_nameContext)
}

func (s *CommentstmtContext) IS() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserIS, 0)
}

func (s *CommentstmtContext) Comment_text() IComment_textContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IComment_textContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IComment_textContext)
}

func (s *CommentstmtContext) COLUMN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCOLUMN, 0)
}

func (s *CommentstmtContext) Object_type_name() IObject_type_nameContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IObject_type_nameContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IObject_type_nameContext)
}

func (s *CommentstmtContext) Name() INameContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(INameContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(INameContext)
}

func (s *CommentstmtContext) TYPE_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserTYPE_P, 0)
}

func (s *CommentstmtContext) AllTypename() []ITypenameContext {
	children := s.GetChildren()
	len := 0
	for _, ctx := range children {
		if _, ok := ctx.(ITypenameContext); ok {
			len++
		}
	}

	tst := make([]ITypenameContext, len)
	i := 0
	for _, ctx := range children {
		if t, ok := ctx.(ITypenameContext); ok {
			tst[i] = t.(ITypenameContext)
			i++
		}
	}

	return tst
}

func (s *CommentstmtContext) Typename(i int) ITypenameContext {
	var t antlr.RuleContext
	j := 0
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ITypenameContext); ok {
			if j == i {
				t = ctx.(antlr.RuleContext)
				break
			}
			j++
		}
	}

	if t == nil {
		return nil
	}

	return t.(ITypenameContext)
}

func (s *CommentstmtContext) DOMAIN_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserDOMAIN_P, 0)
}

func (s *CommentstmtContext) AGGREGATE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserAGGREGATE, 0)
}

func (s *CommentstmtContext) Aggregate_with_argtypes() IAggregate_with_argtypesContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IAggregate_with_argtypesContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IAggregate_with_argtypesContext)
}

func (s *CommentstmtContext) FUNCTION() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserFUNCTION, 0)
}

func (s *CommentstmtContext) Function_with_argtypes() IFunction_with_argtypesContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IFunction_with_argtypesContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IFunction_with_argtypesContext)
}

func (s *CommentstmtContext) OPERATOR() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserOPERATOR, 0)
}

func (s *CommentstmtContext) Operator_with_argtypes() IOperator_with_argtypesContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOperator_with_argtypesContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOperator_with_argtypesContext)
}

func (s *CommentstmtContext) CONSTRAINT() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCONSTRAINT, 0)
}

func (s *CommentstmtContext) Object_type_name_on_any_name() IObject_type_name_on_any_nameContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IObject_type_name_on_any_nameContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IObject_type_name_on_any_nameContext)
}

func (s *CommentstmtContext) PROCEDURE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserPROCEDURE, 0)
}

func (s *CommentstmtContext) ROUTINE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserROUTINE, 0)
}

func (s *CommentstmtContext) TRANSFORM() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserTRANSFORM, 0)
}

func (s *CommentstmtContext) FOR() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserFOR, 0)
}

func (s *CommentstmtContext) LANGUAGE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserLANGUAGE, 0)
}

func (s *CommentstmtContext) CLASS() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCLASS, 0)
}

func (s *CommentstmtContext) USING() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserUSING, 0)
}

func (s *CommentstmtContext) FAMILY() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserFAMILY, 0)
}

func (s *CommentstmtContext) LARGE_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserLARGE_P, 0)
}

func (s *CommentstmtContext) OBJECT_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserOBJECT_P, 0)
}

func (s *CommentstmtContext) Numericonly() INumericonlyContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(INumericonlyContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(INumericonlyContext)
}

func (s *CommentstmtContext) CAST() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCAST, 0)
}

func (s *CommentstmtContext) OPEN_PAREN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserOPEN_PAREN, 0)
}

func (s *CommentstmtContext) AS() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserAS, 0)
}

func (s *CommentstmtContext) CLOSE_PAREN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCLOSE_PAREN, 0)
}

func (s *CommentstmtContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *CommentstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *CommentstmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterCommentstmt(s)
	}
}

func (s *CommentstmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitCommentstmt(s)
	}
}

func (s *CommentstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitCommentstmt(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Commentstmt() (localctx ICommentstmtContext) {
	localctx = NewCommentstmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 534, PostgreSQLParserRULE_commentstmt)
	p.SetState(4814)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 227, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(4667)
			p.Match(PostgreSQLParserCOMMENT)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4668)
			p.Match(PostgreSQLParserON)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4669)
			p.Object_type_any_name()
		}
		{
			p.SetState(4670)
			p.Any_name()
		}
		{
			p.SetState(4671)
			p.Match(PostgreSQLParserIS)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4672)
			p.Comment_text()
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(4674)
			p.Match(PostgreSQLParserCOMMENT)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4675)
			p.Match(PostgreSQLParserON)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4676)
			p.Match(PostgreSQLParserCOLUMN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4677)
			p.Any_name()
		}
		{
			p.SetState(4678)
			p.Match(PostgreSQLParserIS)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4679)
			p.Comment_text()
		}

	case 3:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(4681)
			p.Match(PostgreSQLParserCOMMENT)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4682)
			p.Match(PostgreSQLParserON)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4683)
			p.Object_type_name()
		}
		{
			p.SetState(4684)
			p.Name()
		}
		{
			p.SetState(4685)
			p.Match(PostgreSQLParserIS)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4686)
			p.Comment_text()
		}

	case 4:
		p.EnterOuterAlt(localctx, 4)
		{
			p.SetState(4688)
			p.Match(PostgreSQLParserCOMMENT)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4689)
			p.Match(PostgreSQLParserON)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4690)
			p.Match(PostgreSQLParserTYPE_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4691)
			p.Typename()
		}
		{
			p.SetState(4692)
			p.Match(PostgreSQLParserIS)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4693)
			p.Comment_text()
		}

	case 5:
		p.EnterOuterAlt(localctx, 5)
		{
			p.SetState(4695)
			p.Match(PostgreSQLParserCOMMENT)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4696)
			p.Match(PostgreSQLParserON)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4697)
			p.Match(PostgreSQLParserDOMAIN_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4698)
			p.Typename()
		}
		{
			p.SetState(4699)
			p.Match(PostgreSQLParserIS)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4700)
			p.Comment_text()
		}

	case 6:
		p.EnterOuterAlt(localctx, 6)
		{
			p.SetState(4702)
			p.Match(PostgreSQLParserCOMMENT)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4703)
			p.Match(PostgreSQLParserON)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4704)
			p.Match(PostgreSQLParserAGGREGATE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4705)
			p.Aggregate_with_argtypes()
		}
		{
			p.SetState(4706)
			p.Match(PostgreSQLParserIS)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4707)
			p.Comment_text()
		}

	case 7:
		p.EnterOuterAlt(localctx, 7)
		{
			p.SetState(4709)
			p.Match(PostgreSQLParserCOMMENT)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4710)
			p.Match(PostgreSQLParserON)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4711)
			p.Match(PostgreSQLParserFUNCTION)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4712)
			p.Function_with_argtypes()
		}
		{
			p.SetState(4713)
			p.Match(PostgreSQLParserIS)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4714)
			p.Comment_text()
		}

	case 8:
		p.EnterOuterAlt(localctx, 8)
		{
			p.SetState(4716)
			p.Match(PostgreSQLParserCOMMENT)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4717)
			p.Match(PostgreSQLParserON)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4718)
			p.Match(PostgreSQLParserOPERATOR)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4719)
			p.Operator_with_argtypes()
		}
		{
			p.SetState(4720)
			p.Match(PostgreSQLParserIS)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4721)
			p.Comment_text()
		}

	case 9:
		p.EnterOuterAlt(localctx, 9)
		{
			p.SetState(4723)
			p.Match(PostgreSQLParserCOMMENT)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4724)
			p.Match(PostgreSQLParserON)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4725)
			p.Match(PostgreSQLParserCONSTRAINT)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4726)
			p.Name()
		}
		{
			p.SetState(4727)
			p.Match(PostgreSQLParserON)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4728)
			p.Any_name()
		}
		{
			p.SetState(4729)
			p.Match(PostgreSQLParserIS)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4730)
			p.Comment_text()
		}

	case 10:
		p.EnterOuterAlt(localctx, 10)
		{
			p.SetState(4732)
			p.Match(PostgreSQLParserCOMMENT)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4733)
			p.Match(PostgreSQLParserON)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4734)
			p.Match(PostgreSQLParserCONSTRAINT)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4735)
			p.Name()
		}
		{
			p.SetState(4736)
			p.Match(PostgreSQLParserON)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4737)
			p.Match(PostgreSQLParserDOMAIN_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4738)
			p.Any_name()
		}
		{
			p.SetState(4739)
			p.Match(PostgreSQLParserIS)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4740)
			p.Comment_text()
		}

	case 11:
		p.EnterOuterAlt(localctx, 11)
		{
			p.SetState(4742)
			p.Match(PostgreSQLParserCOMMENT)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4743)
			p.Match(PostgreSQLParserON)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4744)
			p.Object_type_name_on_any_name()
		}
		{
			p.SetState(4745)
			p.Name()
		}
		{
			p.SetState(4746)
			p.Match(PostgreSQLParserON)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4747)
			p.Any_name()
		}
		{
			p.SetState(4748)
			p.Match(PostgreSQLParserIS)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4749)
			p.Comment_text()
		}

	case 12:
		p.EnterOuterAlt(localctx, 12)
		{
			p.SetState(4751)
			p.Match(PostgreSQLParserCOMMENT)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4752)
			p.Match(PostgreSQLParserON)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4753)
			p.Match(PostgreSQLParserPROCEDURE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4754)
			p.Function_with_argtypes()
		}
		{
			p.SetState(4755)
			p.Match(PostgreSQLParserIS)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4756)
			p.Comment_text()
		}

	case 13:
		p.EnterOuterAlt(localctx, 13)
		{
			p.SetState(4758)
			p.Match(PostgreSQLParserCOMMENT)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4759)
			p.Match(PostgreSQLParserON)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4760)
			p.Match(PostgreSQLParserROUTINE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4761)
			p.Function_with_argtypes()
		}
		{
			p.SetState(4762)
			p.Match(PostgreSQLParserIS)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4763)
			p.Comment_text()
		}

	case 14:
		p.EnterOuterAlt(localctx, 14)
		{
			p.SetState(4765)
			p.Match(PostgreSQLParserCOMMENT)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4766)
			p.Match(PostgreSQLParserON)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4767)
			p.Match(PostgreSQLParserTRANSFORM)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4768)
			p.Match(PostgreSQLParserFOR)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4769)
			p.Typename()
		}
		{
			p.SetState(4770)
			p.Match(PostgreSQLParserLANGUAGE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4771)
			p.Name()
		}
		{
			p.SetState(4772)
			p.Match(PostgreSQLParserIS)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4773)
			p.Comment_text()
		}

	case 15:
		p.EnterOuterAlt(localctx, 15)
		{
			p.SetState(4775)
			p.Match(PostgreSQLParserCOMMENT)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4776)
			p.Match(PostgreSQLParserON)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4777)
			p.Match(PostgreSQLParserOPERATOR)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4778)
			p.Match(PostgreSQLParserCLASS)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4779)
			p.Any_name()
		}
		{
			p.SetState(4780)
			p.Match(PostgreSQLParserUSING)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4781)
			p.Name()
		}
		{
			p.SetState(4782)
			p.Match(PostgreSQLParserIS)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4783)
			p.Comment_text()
		}

	case 16:
		p.EnterOuterAlt(localctx, 16)
		{
			p.SetState(4785)
			p.Match(PostgreSQLParserCOMMENT)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4786)
			p.Match(PostgreSQLParserON)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4787)
			p.Match(PostgreSQLParserOPERATOR)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4788)
			p.Match(PostgreSQLParserFAMILY)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4789)
			p.Any_name()
		}
		{
			p.SetState(4790)
			p.Match(PostgreSQLParserUSING)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4791)
			p.Name()
		}
		{
			p.SetState(4792)
			p.Match(PostgreSQLParserIS)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4793)
			p.Comment_text()
		}

	case 17:
		p.EnterOuterAlt(localctx, 17)
		{
			p.SetState(4795)
			p.Match(PostgreSQLParserCOMMENT)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4796)
			p.Match(PostgreSQLParserON)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4797)
			p.Match(PostgreSQLParserLARGE_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4798)
			p.Match(PostgreSQLParserOBJECT_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4799)
			p.Numericonly()
		}
		{
			p.SetState(4800)
			p.Match(PostgreSQLParserIS)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4801)
			p.Comment_text()
		}

	case 18:
		p.EnterOuterAlt(localctx, 18)
		{
			p.SetState(4803)
			p.Match(PostgreSQLParserCOMMENT)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4804)
			p.Match(PostgreSQLParserON)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4805)
			p.Match(PostgreSQLParserCAST)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4806)
			p.Match(PostgreSQLParserOPEN_PAREN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4807)
			p.Typename()
		}
		{
			p.SetState(4808)
			p.Match(PostgreSQLParserAS)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4809)
			p.Typename()
		}
		{
			p.SetState(4810)
			p.Match(PostgreSQLParserCLOSE_PAREN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4811)
			p.Match(PostgreSQLParserIS)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4812)
			p.Comment_text()
		}

	case antlr.ATNInvalidAltNumber:
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IComment_textContext is an interface to support dynamic dispatch.
type IComment_textContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Sconst() ISconstContext
	NULL_P() antlr.TerminalNode

	// IsComment_textContext differentiates from other interfaces.
	IsComment_textContext()
}

type Comment_textContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyComment_textContext() *Comment_textContext {
	var p = new(Comment_textContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_comment_text
	return p
}

func InitEmptyComment_textContext(p *Comment_textContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_comment_text
}

func (*Comment_textContext) IsComment_textContext() {}

func NewComment_textContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Comment_textContext {
	var p = new(Comment_textContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_comment_text

	return p
}

func (s *Comment_textContext) GetParser() antlr.Parser { return s.parser }

func (s *Comment_textContext) Sconst() ISconstContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ISconstContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ISconstContext)
}

func (s *Comment_textContext) NULL_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserNULL_P, 0)
}

func (s *Comment_textContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Comment_textContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Comment_textContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterComment_text(s)
	}
}

func (s *Comment_textContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitComment_text(s)
	}
}

func (s *Comment_textContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitComment_text(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Comment_text() (localctx IComment_textContext) {
	localctx = NewComment_textContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 536, PostgreSQLParserRULE_comment_text)
	p.SetState(4818)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetTokenStream().LA(1) {
	case PostgreSQLParserStringConstant, PostgreSQLParserUnicodeEscapeStringConstant, PostgreSQLParserBeginDollarStringConstant, PostgreSQLParserEscapeStringConstant:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(4816)
			p.Sconst()
		}

	case PostgreSQLParserNULL_P:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(4817)
			p.Match(PostgreSQLParserNULL_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	default:
		p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// ISeclabelstmtContext is an interface to support dynamic dispatch.
type ISeclabelstmtContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	SECURITY() antlr.TerminalNode
	LABEL() antlr.TerminalNode
	Opt_provider() IOpt_providerContext
	ON() antlr.TerminalNode
	Object_type_any_name() IObject_type_any_nameContext
	Any_name() IAny_nameContext
	IS() antlr.TerminalNode
	Security_label() ISecurity_labelContext
	COLUMN() antlr.TerminalNode
	Object_type_name() IObject_type_nameContext
	Name() INameContext
	TYPE_P() antlr.TerminalNode
	Typename() ITypenameContext
	DOMAIN_P() antlr.TerminalNode
	AGGREGATE() antlr.TerminalNode
	Aggregate_with_argtypes() IAggregate_with_argtypesContext
	FUNCTION() antlr.TerminalNode
	Function_with_argtypes() IFunction_with_argtypesContext
	LARGE_P() antlr.TerminalNode
	OBJECT_P() antlr.TerminalNode
	Numericonly() INumericonlyContext
	PROCEDURE() antlr.TerminalNode
	ROUTINE() antlr.TerminalNode

	// IsSeclabelstmtContext differentiates from other interfaces.
	IsSeclabelstmtContext()
}

type SeclabelstmtContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptySeclabelstmtContext() *SeclabelstmtContext {
	var p = new(SeclabelstmtContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_seclabelstmt
	return p
}

func InitEmptySeclabelstmtContext(p *SeclabelstmtContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_seclabelstmt
}

func (*SeclabelstmtContext) IsSeclabelstmtContext() {}

func NewSeclabelstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SeclabelstmtContext {
	var p = new(SeclabelstmtContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_seclabelstmt

	return p
}

func (s *SeclabelstmtContext) GetParser() antlr.Parser { return s.parser }

func (s *SeclabelstmtContext) SECURITY() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserSECURITY, 0)
}

func (s *SeclabelstmtContext) LABEL() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserLABEL, 0)
}

func (s *SeclabelstmtContext) Opt_provider() IOpt_providerContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOpt_providerContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOpt_providerContext)
}

func (s *SeclabelstmtContext) ON() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserON, 0)
}

func (s *SeclabelstmtContext) Object_type_any_name() IObject_type_any_nameContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IObject_type_any_nameContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IObject_type_any_nameContext)
}

func (s *SeclabelstmtContext) Any_name() IAny_nameContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IAny_nameContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IAny_nameContext)
}

func (s *SeclabelstmtContext) IS() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserIS, 0)
}

func (s *SeclabelstmtContext) Security_label() ISecurity_labelContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ISecurity_labelContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ISecurity_labelContext)
}

func (s *SeclabelstmtContext) COLUMN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCOLUMN, 0)
}

func (s *SeclabelstmtContext) Object_type_name() IObject_type_nameContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IObject_type_nameContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IObject_type_nameContext)
}

func (s *SeclabelstmtContext) Name() INameContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(INameContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(INameContext)
}

func (s *SeclabelstmtContext) TYPE_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserTYPE_P, 0)
}

func (s *SeclabelstmtContext) Typename() ITypenameContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ITypenameContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ITypenameContext)
}

func (s *SeclabelstmtContext) DOMAIN_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserDOMAIN_P, 0)
}

func (s *SeclabelstmtContext) AGGREGATE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserAGGREGATE, 0)
}

func (s *SeclabelstmtContext) Aggregate_with_argtypes() IAggregate_with_argtypesContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IAggregate_with_argtypesContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IAggregate_with_argtypesContext)
}

func (s *SeclabelstmtContext) FUNCTION() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserFUNCTION, 0)
}

func (s *SeclabelstmtContext) Function_with_argtypes() IFunction_with_argtypesContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IFunction_with_argtypesContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IFunction_with_argtypesContext)
}

func (s *SeclabelstmtContext) LARGE_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserLARGE_P, 0)
}

func (s *SeclabelstmtContext) OBJECT_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserOBJECT_P, 0)
}

func (s *SeclabelstmtContext) Numericonly() INumericonlyContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(INumericonlyContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(INumericonlyContext)
}

func (s *SeclabelstmtContext) PROCEDURE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserPROCEDURE, 0)
}

func (s *SeclabelstmtContext) ROUTINE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserROUTINE, 0)
}

func (s *SeclabelstmtContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *SeclabelstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *SeclabelstmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterSeclabelstmt(s)
	}
}

func (s *SeclabelstmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitSeclabelstmt(s)
	}
}

func (s *SeclabelstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitSeclabelstmt(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Seclabelstmt() (localctx ISeclabelstmtContext) {
	localctx = NewSeclabelstmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 538, PostgreSQLParserRULE_seclabelstmt)
	p.SetState(4911)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 229, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(4820)
			p.Match(PostgreSQLParserSECURITY)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4821)
			p.Match(PostgreSQLParserLABEL)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4822)
			p.Opt_provider()
		}
		{
			p.SetState(4823)
			p.Match(PostgreSQLParserON)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4824)
			p.Object_type_any_name()
		}
		{
			p.SetState(4825)
			p.Any_name()
		}
		{
			p.SetState(4826)
			p.Match(PostgreSQLParserIS)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4827)
			p.Security_label()
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(4829)
			p.Match(PostgreSQLParserSECURITY)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4830)
			p.Match(PostgreSQLParserLABEL)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4831)
			p.Opt_provider()
		}
		{
			p.SetState(4832)
			p.Match(PostgreSQLParserON)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4833)
			p.Match(PostgreSQLParserCOLUMN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4834)
			p.Any_name()
		}
		{
			p.SetState(4835)
			p.Match(PostgreSQLParserIS)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4836)
			p.Security_label()
		}

	case 3:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(4838)
			p.Match(PostgreSQLParserSECURITY)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4839)
			p.Match(PostgreSQLParserLABEL)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4840)
			p.Opt_provider()
		}
		{
			p.SetState(4841)
			p.Match(PostgreSQLParserON)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4842)
			p.Object_type_name()
		}
		{
			p.SetState(4843)
			p.Name()
		}
		{
			p.SetState(4844)
			p.Match(PostgreSQLParserIS)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4845)
			p.Security_label()
		}

	case 4:
		p.EnterOuterAlt(localctx, 4)
		{
			p.SetState(4847)
			p.Match(PostgreSQLParserSECURITY)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4848)
			p.Match(PostgreSQLParserLABEL)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4849)
			p.Opt_provider()
		}
		{
			p.SetState(4850)
			p.Match(PostgreSQLParserON)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4851)
			p.Match(PostgreSQLParserTYPE_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4852)
			p.Typename()
		}
		{
			p.SetState(4853)
			p.Match(PostgreSQLParserIS)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4854)
			p.Security_label()
		}

	case 5:
		p.EnterOuterAlt(localctx, 5)
		{
			p.SetState(4856)
			p.Match(PostgreSQLParserSECURITY)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4857)
			p.Match(PostgreSQLParserLABEL)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4858)
			p.Opt_provider()
		}
		{
			p.SetState(4859)
			p.Match(PostgreSQLParserON)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4860)
			p.Match(PostgreSQLParserDOMAIN_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4861)
			p.Typename()
		}
		{
			p.SetState(4862)
			p.Match(PostgreSQLParserIS)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4863)
			p.Security_label()
		}

	case 6:
		p.EnterOuterAlt(localctx, 6)
		{
			p.SetState(4865)
			p.Match(PostgreSQLParserSECURITY)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4866)
			p.Match(PostgreSQLParserLABEL)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4867)
			p.Opt_provider()
		}
		{
			p.SetState(4868)
			p.Match(PostgreSQLParserON)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4869)
			p.Match(PostgreSQLParserAGGREGATE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4870)
			p.Aggregate_with_argtypes()
		}
		{
			p.SetState(4871)
			p.Match(PostgreSQLParserIS)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4872)
			p.Security_label()
		}

	case 7:
		p.EnterOuterAlt(localctx, 7)
		{
			p.SetState(4874)
			p.Match(PostgreSQLParserSECURITY)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4875)
			p.Match(PostgreSQLParserLABEL)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4876)
			p.Opt_provider()
		}
		{
			p.SetState(4877)
			p.Match(PostgreSQLParserON)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4878)
			p.Match(PostgreSQLParserFUNCTION)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4879)
			p.Function_with_argtypes()
		}
		{
			p.SetState(4880)
			p.Match(PostgreSQLParserIS)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4881)
			p.Security_label()
		}

	case 8:
		p.EnterOuterAlt(localctx, 8)
		{
			p.SetState(4883)
			p.Match(PostgreSQLParserSECURITY)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4884)
			p.Match(PostgreSQLParserLABEL)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4885)
			p.Opt_provider()
		}
		{
			p.SetState(4886)
			p.Match(PostgreSQLParserON)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4887)
			p.Match(PostgreSQLParserLARGE_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4888)
			p.Match(PostgreSQLParserOBJECT_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4889)
			p.Numericonly()
		}
		{
			p.SetState(4890)
			p.Match(PostgreSQLParserIS)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4891)
			p.Security_label()
		}

	case 9:
		p.EnterOuterAlt(localctx, 9)
		{
			p.SetState(4893)
			p.Match(PostgreSQLParserSECURITY)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4894)
			p.Match(PostgreSQLParserLABEL)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4895)
			p.Opt_provider()
		}
		{
			p.SetState(4896)
			p.Match(PostgreSQLParserON)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4897)
			p.Match(PostgreSQLParserPROCEDURE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4898)
			p.Function_with_argtypes()
		}
		{
			p.SetState(4899)
			p.Match(PostgreSQLParserIS)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4900)
			p.Security_label()
		}

	case 10:
		p.EnterOuterAlt(localctx, 10)
		{
			p.SetState(4902)
			p.Match(PostgreSQLParserSECURITY)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4903)
			p.Match(PostgreSQLParserLABEL)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4904)
			p.Opt_provider()
		}
		{
			p.SetState(4905)
			p.Match(PostgreSQLParserON)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4906)
			p.Match(PostgreSQLParserROUTINE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4907)
			p.Function_with_argtypes()
		}
		{
			p.SetState(4908)
			p.Match(PostgreSQLParserIS)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4909)
			p.Security_label()
		}

	case antlr.ATNInvalidAltNumber:
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IOpt_providerContext is an interface to support dynamic dispatch.
type IOpt_providerContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	FOR() antlr.TerminalNode
	Nonreservedword_or_sconst() INonreservedword_or_sconstContext

	// IsOpt_providerContext differentiates from other interfaces.
	IsOpt_providerContext()
}

type Opt_providerContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyOpt_providerContext() *Opt_providerContext {
	var p = new(Opt_providerContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opt_provider
	return p
}

func InitEmptyOpt_providerContext(p *Opt_providerContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opt_provider
}

func (*Opt_providerContext) IsOpt_providerContext() {}

func NewOpt_providerContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_providerContext {
	var p = new(Opt_providerContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_opt_provider

	return p
}

func (s *Opt_providerContext) GetParser() antlr.Parser { return s.parser }

func (s *Opt_providerContext) FOR() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserFOR, 0)
}

func (s *Opt_providerContext) Nonreservedword_or_sconst() INonreservedword_or_sconstContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(INonreservedword_or_sconstContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(INonreservedword_or_sconstContext)
}

func (s *Opt_providerContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Opt_providerContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Opt_providerContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterOpt_provider(s)
	}
}

func (s *Opt_providerContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitOpt_provider(s)
	}
}

func (s *Opt_providerContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitOpt_provider(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Opt_provider() (localctx IOpt_providerContext) {
	localctx = NewOpt_providerContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 540, PostgreSQLParserRULE_opt_provider)
	p.SetState(4916)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetTokenStream().LA(1) {
	case PostgreSQLParserFOR:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(4913)
			p.Match(PostgreSQLParserFOR)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4914)
			p.Nonreservedword_or_sconst()
		}

	case PostgreSQLParserON:
		p.EnterOuterAlt(localctx, 2)

	default:
		p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// ISecurity_labelContext is an interface to support dynamic dispatch.
type ISecurity_labelContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Sconst() ISconstContext
	NULL_P() antlr.TerminalNode

	// IsSecurity_labelContext differentiates from other interfaces.
	IsSecurity_labelContext()
}

type Security_labelContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptySecurity_labelContext() *Security_labelContext {
	var p = new(Security_labelContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_security_label
	return p
}

func InitEmptySecurity_labelContext(p *Security_labelContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_security_label
}

func (*Security_labelContext) IsSecurity_labelContext() {}

func NewSecurity_labelContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Security_labelContext {
	var p = new(Security_labelContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_security_label

	return p
}

func (s *Security_labelContext) GetParser() antlr.Parser { return s.parser }

func (s *Security_labelContext) Sconst() ISconstContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ISconstContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ISconstContext)
}

func (s *Security_labelContext) NULL_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserNULL_P, 0)
}

func (s *Security_labelContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Security_labelContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Security_labelContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterSecurity_label(s)
	}
}

func (s *Security_labelContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitSecurity_label(s)
	}
}

func (s *Security_labelContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitSecurity_label(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Security_label() (localctx ISecurity_labelContext) {
	localctx = NewSecurity_labelContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 542, PostgreSQLParserRULE_security_label)
	p.SetState(4920)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetTokenStream().LA(1) {
	case PostgreSQLParserStringConstant, PostgreSQLParserUnicodeEscapeStringConstant, PostgreSQLParserBeginDollarStringConstant, PostgreSQLParserEscapeStringConstant:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(4918)
			p.Sconst()
		}

	case PostgreSQLParserNULL_P:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(4919)
			p.Match(PostgreSQLParserNULL_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	default:
		p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IFetchstmtContext is an interface to support dynamic dispatch.
type IFetchstmtContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	FETCH() antlr.TerminalNode
	Fetch_args() IFetch_argsContext
	MOVE() antlr.TerminalNode

	// IsFetchstmtContext differentiates from other interfaces.
	IsFetchstmtContext()
}

type FetchstmtContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyFetchstmtContext() *FetchstmtContext {
	var p = new(FetchstmtContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_fetchstmt
	return p
}

func InitEmptyFetchstmtContext(p *FetchstmtContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_fetchstmt
}

func (*FetchstmtContext) IsFetchstmtContext() {}

func NewFetchstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *FetchstmtContext {
	var p = new(FetchstmtContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_fetchstmt

	return p
}

func (s *FetchstmtContext) GetParser() antlr.Parser { return s.parser }

func (s *FetchstmtContext) FETCH() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserFETCH, 0)
}

func (s *FetchstmtContext) Fetch_args() IFetch_argsContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IFetch_argsContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IFetch_argsContext)
}

func (s *FetchstmtContext) MOVE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserMOVE, 0)
}

func (s *FetchstmtContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *FetchstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *FetchstmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterFetchstmt(s)
	}
}

func (s *FetchstmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitFetchstmt(s)
	}
}

func (s *FetchstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitFetchstmt(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Fetchstmt() (localctx IFetchstmtContext) {
	localctx = NewFetchstmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 544, PostgreSQLParserRULE_fetchstmt)
	p.SetState(4926)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetTokenStream().LA(1) {
	case PostgreSQLParserFETCH:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(4922)
			p.Match(PostgreSQLParserFETCH)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4923)
			p.Fetch_args()
		}

	case PostgreSQLParserMOVE:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(4924)
			p.Match(PostgreSQLParserMOVE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4925)
			p.Fetch_args()
		}

	default:
		p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IFetch_argsContext is an interface to support dynamic dispatch.
type IFetch_argsContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Cursor_name() ICursor_nameContext
	From_in() IFrom_inContext
	NEXT() antlr.TerminalNode
	Opt_from_in() IOpt_from_inContext
	PRIOR() antlr.TerminalNode
	FIRST_P() antlr.TerminalNode
	LAST_P() antlr.TerminalNode
	ABSOLUTE_P() antlr.TerminalNode
	Signediconst() ISignediconstContext
	RELATIVE_P() antlr.TerminalNode
	ALL() antlr.TerminalNode
	FORWARD() antlr.TerminalNode
	BACKWARD() antlr.TerminalNode

	// IsFetch_argsContext differentiates from other interfaces.
	IsFetch_argsContext()
}

type Fetch_argsContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyFetch_argsContext() *Fetch_argsContext {
	var p = new(Fetch_argsContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_fetch_args
	return p
}

func InitEmptyFetch_argsContext(p *Fetch_argsContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_fetch_args
}

func (*Fetch_argsContext) IsFetch_argsContext() {}

func NewFetch_argsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Fetch_argsContext {
	var p = new(Fetch_argsContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_fetch_args

	return p
}

func (s *Fetch_argsContext) GetParser() antlr.Parser { return s.parser }

func (s *Fetch_argsContext) Cursor_name() ICursor_nameContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ICursor_nameContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ICursor_nameContext)
}

func (s *Fetch_argsContext) From_in() IFrom_inContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IFrom_inContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IFrom_inContext)
}

func (s *Fetch_argsContext) NEXT() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserNEXT, 0)
}

func (s *Fetch_argsContext) Opt_from_in() IOpt_from_inContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOpt_from_inContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOpt_from_inContext)
}

func (s *Fetch_argsContext) PRIOR() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserPRIOR, 0)
}

func (s *Fetch_argsContext) FIRST_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserFIRST_P, 0)
}

func (s *Fetch_argsContext) LAST_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserLAST_P, 0)
}

func (s *Fetch_argsContext) ABSOLUTE_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserABSOLUTE_P, 0)
}

func (s *Fetch_argsContext) Signediconst() ISignediconstContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ISignediconstContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ISignediconstContext)
}

func (s *Fetch_argsContext) RELATIVE_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserRELATIVE_P, 0)
}

func (s *Fetch_argsContext) ALL() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserALL, 0)
}

func (s *Fetch_argsContext) FORWARD() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserFORWARD, 0)
}

func (s *Fetch_argsContext) BACKWARD() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserBACKWARD, 0)
}

func (s *Fetch_argsContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Fetch_argsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Fetch_argsContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterFetch_args(s)
	}
}

func (s *Fetch_argsContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitFetch_args(s)
	}
}

func (s *Fetch_argsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitFetch_args(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Fetch_args() (localctx IFetch_argsContext) {
	localctx = NewFetch_argsContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 546, PostgreSQLParserRULE_fetch_args)
	p.SetState(4994)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 233, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(4928)
			p.Cursor_name()
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(4929)
			p.From_in()
		}
		{
			p.SetState(4930)
			p.Cursor_name()
		}

	case 3:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(4932)
			p.Match(PostgreSQLParserNEXT)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4933)
			p.Opt_from_in()
		}
		{
			p.SetState(4934)
			p.Cursor_name()
		}

	case 4:
		p.EnterOuterAlt(localctx, 4)
		{
			p.SetState(4936)
			p.Match(PostgreSQLParserPRIOR)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4937)
			p.Opt_from_in()
		}
		{
			p.SetState(4938)
			p.Cursor_name()
		}

	case 5:
		p.EnterOuterAlt(localctx, 5)
		{
			p.SetState(4940)
			p.Match(PostgreSQLParserFIRST_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4941)
			p.Opt_from_in()
		}
		{
			p.SetState(4942)
			p.Cursor_name()
		}

	case 6:
		p.EnterOuterAlt(localctx, 6)
		{
			p.SetState(4944)
			p.Match(PostgreSQLParserLAST_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4945)
			p.Opt_from_in()
		}
		{
			p.SetState(4946)
			p.Cursor_name()
		}

	case 7:
		p.EnterOuterAlt(localctx, 7)
		{
			p.SetState(4948)
			p.Match(PostgreSQLParserABSOLUTE_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4949)
			p.Signediconst()
		}
		{
			p.SetState(4950)
			p.Opt_from_in()
		}
		{
			p.SetState(4951)
			p.Cursor_name()
		}

	case 8:
		p.EnterOuterAlt(localctx, 8)
		{
			p.SetState(4953)
			p.Match(PostgreSQLParserRELATIVE_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4954)
			p.Signediconst()
		}
		{
			p.SetState(4955)
			p.Opt_from_in()
		}
		{
			p.SetState(4956)
			p.Cursor_name()
		}

	case 9:
		p.EnterOuterAlt(localctx, 9)
		{
			p.SetState(4958)
			p.Signediconst()
		}
		{
			p.SetState(4959)
			p.Opt_from_in()
		}
		{
			p.SetState(4960)
			p.Cursor_name()
		}

	case 10:
		p.EnterOuterAlt(localctx, 10)
		{
			p.SetState(4962)
			p.Match(PostgreSQLParserALL)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4963)
			p.Opt_from_in()
		}
		{
			p.SetState(4964)
			p.Cursor_name()
		}

	case 11:
		p.EnterOuterAlt(localctx, 11)
		{
			p.SetState(4966)
			p.Match(PostgreSQLParserFORWARD)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4967)
			p.Opt_from_in()
		}
		{
			p.SetState(4968)
			p.Cursor_name()
		}

	case 12:
		p.EnterOuterAlt(localctx, 12)
		{
			p.SetState(4970)
			p.Match(PostgreSQLParserFORWARD)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4971)
			p.Signediconst()
		}
		{
			p.SetState(4972)
			p.Opt_from_in()
		}
		{
			p.SetState(4973)
			p.Cursor_name()
		}

	case 13:
		p.EnterOuterAlt(localctx, 13)
		{
			p.SetState(4975)
			p.Match(PostgreSQLParserFORWARD)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4976)
			p.Match(PostgreSQLParserALL)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4977)
			p.Opt_from_in()
		}
		{
			p.SetState(4978)
			p.Cursor_name()
		}

	case 14:
		p.EnterOuterAlt(localctx, 14)
		{
			p.SetState(4980)
			p.Match(PostgreSQLParserBACKWARD)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4981)
			p.Opt_from_in()
		}
		{
			p.SetState(4982)
			p.Cursor_name()
		}

	case 15:
		p.EnterOuterAlt(localctx, 15)
		{
			p.SetState(4984)
			p.Match(PostgreSQLParserBACKWARD)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4985)
			p.Signediconst()
		}
		{
			p.SetState(4986)
			p.Opt_from_in()
		}
		{
			p.SetState(4987)
			p.Cursor_name()
		}

	case 16:
		p.EnterOuterAlt(localctx, 16)
		{
			p.SetState(4989)
			p.Match(PostgreSQLParserBACKWARD)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4990)
			p.Match(PostgreSQLParserALL)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(4991)
			p.Opt_from_in()
		}
		{
			p.SetState(4992)
			p.Cursor_name()
		}

	case antlr.ATNInvalidAltNumber:
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IFrom_inContext is an interface to support dynamic dispatch.
type IFrom_inContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	FROM() antlr.TerminalNode
	IN_P() antlr.TerminalNode

	// IsFrom_inContext differentiates from other interfaces.
	IsFrom_inContext()
}

type From_inContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyFrom_inContext() *From_inContext {
	var p = new(From_inContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_from_in
	return p
}

func InitEmptyFrom_inContext(p *From_inContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_from_in
}

func (*From_inContext) IsFrom_inContext() {}

func NewFrom_inContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *From_inContext {
	var p = new(From_inContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_from_in

	return p
}

func (s *From_inContext) GetParser() antlr.Parser { return s.parser }

func (s *From_inContext) FROM() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserFROM, 0)
}

func (s *From_inContext) IN_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserIN_P, 0)
}

func (s *From_inContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *From_inContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *From_inContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterFrom_in(s)
	}
}

func (s *From_inContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitFrom_in(s)
	}
}

func (s *From_inContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitFrom_in(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) From_in() (localctx IFrom_inContext) {
	localctx = NewFrom_inContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 548, PostgreSQLParserRULE_from_in)
	var _la int

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(4996)
		_la = p.GetTokenStream().LA(1)

		if !(_la == PostgreSQLParserFROM || _la == PostgreSQLParserIN_P) {
			p.GetErrorHandler().RecoverInline(p)
		} else {
			p.GetErrorHandler().ReportMatch(p)
			p.Consume()
		}
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IOpt_from_inContext is an interface to support dynamic dispatch.
type IOpt_from_inContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	From_in() IFrom_inContext

	// IsOpt_from_inContext differentiates from other interfaces.
	IsOpt_from_inContext()
}

type Opt_from_inContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyOpt_from_inContext() *Opt_from_inContext {
	var p = new(Opt_from_inContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opt_from_in
	return p
}

func InitEmptyOpt_from_inContext(p *Opt_from_inContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opt_from_in
}

func (*Opt_from_inContext) IsOpt_from_inContext() {}

func NewOpt_from_inContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_from_inContext {
	var p = new(Opt_from_inContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_opt_from_in

	return p
}

func (s *Opt_from_inContext) GetParser() antlr.Parser { return s.parser }

func (s *Opt_from_inContext) From_in() IFrom_inContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IFrom_inContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IFrom_inContext)
}

func (s *Opt_from_inContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Opt_from_inContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Opt_from_inContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterOpt_from_in(s)
	}
}

func (s *Opt_from_inContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitOpt_from_in(s)
	}
}

func (s *Opt_from_inContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitOpt_from_in(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Opt_from_in() (localctx IOpt_from_inContext) {
	localctx = NewOpt_from_inContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 550, PostgreSQLParserRULE_opt_from_in)
	p.SetState(5000)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetTokenStream().LA(1) {
	case PostgreSQLParserFROM, PostgreSQLParserIN_P:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(4998)
			p.From_in()
		}

	case PostgreSQLParserAND, PostgreSQLParserARRAY, PostgreSQLParserCOLLATE, PostgreSQLParserCOLUMN, PostgreSQLParserCONSTRAINT, PostgreSQLParserDEFAULT, PostgreSQLParserDO, PostgreSQLParserFETCH, PostgreSQLParserTABLE, PostgreSQLParserIS, PostgreSQLParserLEFT, PostgreSQLParserOUTER_P, PostgreSQLParserOVER, PostgreSQLParserRIGHT, PostgreSQLParserABORT_P, PostgreSQLParserABSOLUTE_P, PostgreSQLParserACCESS, PostgreSQLParserACTION, PostgreSQLParserADD_P, PostgreSQLParserADMIN, PostgreSQLParserAFTER, PostgreSQLParserAGGREGATE, PostgreSQLParserALSO, PostgreSQLParserALTER, PostgreSQLParserALWAYS, PostgreSQLParserASSERTION, PostgreSQLParserASSIGNMENT, PostgreSQLParserAT, PostgreSQLParserATTRIBUTE, PostgreSQLParserBACKWARD, PostgreSQLParserBEFORE, PostgreSQLParserBEGIN_P, PostgreSQLParserBY, PostgreSQLParserCACHE, PostgreSQLParserCALLED, PostgreSQLParserCASCADE, PostgreSQLParserCASCADED, PostgreSQLParserCATALOG, PostgreSQLParserCHAIN, PostgreSQLParserCHARACTERISTICS, PostgreSQLParserCHECKPOINT, PostgreSQLParserCLASS, PostgreSQLParserCLOSE, PostgreSQLParserCLUSTER, PostgreSQLParserCOMMENT, PostgreSQLParserCOMMENTS, PostgreSQLParserCOMMIT, PostgreSQLParserCOMMITTED, PostgreSQLParserCONFIGURATION, PostgreSQLParserCONNECTION, PostgreSQLParserCONSTRAINTS, PostgreSQLParserCONTENT_P, PostgreSQLParserCONTINUE_P, PostgreSQLParserCONVERSION_P, PostgreSQLParserCOPY, PostgreSQLParserCOST, PostgreSQLParserCSV, PostgreSQLParserCURSOR, PostgreSQLParserCYCLE, PostgreSQLParserDATA_P, PostgreSQLParserDATABASE, PostgreSQLParserDAY_P, PostgreSQLParserDEALLOCATE, PostgreSQLParserDECLARE, PostgreSQLParserDEFAULTS, PostgreSQLParserDEFERRED, PostgreSQLParserDEFINER, PostgreSQLParserDELETE_P, PostgreSQLParserDELIMITER, PostgreSQLParserDELIMITERS, PostgreSQLParserDICTIONARY, PostgreSQLParserDISABLE_P, PostgreSQLParserDISCARD, PostgreSQLParserDOCUMENT_P, PostgreSQLParserDOMAIN_P, PostgreSQLParserDOUBLE_P, PostgreSQLParserDROP, PostgreSQLParserEACH, PostgreSQLParserENABLE_P, PostgreSQLParserENCODING, PostgreSQLParserENCRYPTED, PostgreSQLParserENUM_P, PostgreSQLParserESCAPE, PostgreSQLParserEVENT, PostgreSQLParserEXCLUDE, PostgreSQLParserEXCLUDING, PostgreSQLParserEXCLUSIVE, PostgreSQLParserEXECUTE, PostgreSQLParserEXPLAIN, PostgreSQLParserEXTENSION, PostgreSQLParserEXTERNAL, PostgreSQLParserFAMILY, PostgreSQLParserFIRST_P, PostgreSQLParserFOLLOWING, PostgreSQLParserFORCE, PostgreSQLParserFORWARD, PostgreSQLParserFUNCTION, PostgreSQLParserFUNCTIONS, PostgreSQLParserGLOBAL, PostgreSQLParserGRANTED, PostgreSQLParserHANDLER, PostgreSQLParserHEADER_P, PostgreSQLParserHOLD, PostgreSQLParserHOUR_P, PostgreSQLParserIDENTITY_P, PostgreSQLParserIF_P, PostgreSQLParserIMMEDIATE, PostgreSQLParserIMMUTABLE, PostgreSQLParserIMPLICIT_P, PostgreSQLParserINCLUDING, PostgreSQLParserINCREMENT, PostgreSQLParserINDEX, PostgreSQLParserINDEXES, PostgreSQLParserINHERIT, PostgreSQLParserINHERITS, PostgreSQLParserINLINE_P, PostgreSQLParserINSENSITIVE, PostgreSQLParserINSERT, PostgreSQLParserINSTEAD, PostgreSQLParserINVOKER, PostgreSQLParserISOLATION, PostgreSQLParserKEY, PostgreSQLParserLABEL, PostgreSQLParserLANGUAGE, PostgreSQLParserLARGE_P, PostgreSQLParserLAST_P, PostgreSQLParserLEAKPROOF, PostgreSQLParserLEVEL, PostgreSQLParserLISTEN, PostgreSQLParserLOAD, PostgreSQLParserLOCAL, PostgreSQLParserLOCATION, PostgreSQLParserLOCK_P, PostgreSQLParserMAPPING, PostgreSQLParserMATCH, PostgreSQLParserMATERIALIZED, PostgreSQLParserMAXVALUE, PostgreSQLParserMINUTE_P, PostgreSQLParserMINVALUE, PostgreSQLParserMODE, PostgreSQLParserMONTH_P, PostgreSQLParserMOVE, PostgreSQLParserNAME_P, PostgreSQLParserNAMES, PostgreSQLParserNEXT, PostgreSQLParserNO, PostgreSQLParserNOTHING, PostgreSQLParserNOTIFY, PostgreSQLParserNOWAIT, PostgreSQLParserNULLS_P, PostgreSQLParserOBJECT_P, PostgreSQLParserOF, PostgreSQLParserOFF, PostgreSQLParserOIDS, PostgreSQLParserOPERATOR, PostgreSQLParserOPTION, PostgreSQLParserOPTIONS, PostgreSQLParserOWNED, PostgreSQLParserOWNER, PostgreSQLParserPARSER, PostgreSQLParserPARTIAL, PostgreSQLParserPARTITION, PostgreSQLParserPASSING, PostgreSQLParserPASSWORD, PostgreSQLParserPLANS, PostgreSQLParserPRECEDING, PostgreSQLParserPREPARE, PostgreSQLParserPREPARED, PostgreSQLParserPRESERVE, PostgreSQLParserPRIOR, PostgreSQLParserPRIVILEGES, PostgreSQLParserPROCEDURAL, PostgreSQLParserPROCEDURE, PostgreSQLParserPROGRAM, PostgreSQLParserQUOTE, PostgreSQLParserRANGE, PostgreSQLParserREAD, PostgreSQLParserREASSIGN, PostgreSQLParserRECHECK, PostgreSQLParserRECURSIVE, PostgreSQLParserREF, PostgreSQLParserREFRESH, PostgreSQLParserREINDEX, PostgreSQLParserRELATIVE_P, PostgreSQLParserRELEASE, PostgreSQLParserRENAME, PostgreSQLParserREPEATABLE, PostgreSQLParserREPLACE, PostgreSQLParserREPLICA, PostgreSQLParserRESET, PostgreSQLParserRESTART, PostgreSQLParserRESTRICT, PostgreSQLParserRETURNS, PostgreSQLParserREVOKE, PostgreSQLParserROLE, PostgreSQLParserROLLBACK, PostgreSQLParserROWS, PostgreSQLParserRULE, PostgreSQLParserSAVEPOINT, PostgreSQLParserSCHEMA, PostgreSQLParserSCROLL, PostgreSQLParserSEARCH, PostgreSQLParserSECOND_P, PostgreSQLParserSECURITY, PostgreSQLParserSEQUENCE, PostgreSQLParserSEQUENCES, PostgreSQLParserSERIALIZABLE, PostgreSQLParserSERVER, PostgreSQLParserSESSION, PostgreSQLParserSET, PostgreSQLParserSHARE, PostgreSQLParserSHOW, PostgreSQLParserSIMPLE, PostgreSQLParserSNAPSHOT, PostgreSQLParserSTABLE, PostgreSQLParserSTANDALONE_P, PostgreSQLParserSTART, PostgreSQLParserSTATEMENT, PostgreSQLParserSTATISTICS, PostgreSQLParserSTDIN, PostgreSQLParserSTDOUT, PostgreSQLParserSTORAGE, PostgreSQLParserSTRICT_P, PostgreSQLParserSTRIP_P, PostgreSQLParserSYSID, PostgreSQLParserSYSTEM_P, PostgreSQLParserTABLES, PostgreSQLParserTABLESPACE, PostgreSQLParserTEMP, PostgreSQLParserTEMPLATE, PostgreSQLParserTEMPORARY, PostgreSQLParserTEXT_P, PostgreSQLParserTRANSACTION, PostgreSQLParserTRIGGER, PostgreSQLParserTRUNCATE, PostgreSQLParserTRUSTED, PostgreSQLParserTYPE_P, PostgreSQLParserTYPES_P, PostgreSQLParserUNBOUNDED, PostgreSQLParserUNCOMMITTED, PostgreSQLParserUNENCRYPTED, PostgreSQLParserUNKNOWN, PostgreSQLParserUNLISTEN, PostgreSQLParserUNLOGGED, PostgreSQLParserUNTIL, PostgreSQLParserUPDATE, PostgreSQLParserVACUUM, PostgreSQLParserVALID, PostgreSQLParserVALIDATE, PostgreSQLParserVALIDATOR, PostgreSQLParserVARYING, PostgreSQLParserVERSION_P, PostgreSQLParserVIEW, PostgreSQLParserVOLATILE, PostgreSQLParserWHITESPACE_P, PostgreSQLParserWITHOUT, PostgreSQLParserWORK, PostgreSQLParserWRAPPER, PostgreSQLParserWRITE, PostgreSQLParserXML_P, PostgreSQLParserYEAR_P, PostgreSQLParserYES_P, PostgreSQLParserZONE, PostgreSQLParserBETWEEN, PostgreSQLParserBIGINT, PostgreSQLParserBIT, PostgreSQLParserBOOLEAN_P, PostgreSQLParserCHAR_P, PostgreSQLParserCHARACTER, PostgreSQLParserCOALESCE, PostgreSQLParserDEC, PostgreSQLParserDECIMAL_P, PostgreSQLParserEXISTS, PostgreSQLParserEXTRACT, PostgreSQLParserFLOAT_P, PostgreSQLParserGREATEST, PostgreSQLParserINOUT, PostgreSQLParserINT_P, PostgreSQLParserINTEGER, PostgreSQLParserINTERVAL, PostgreSQLParserLEAST, PostgreSQLParserNATIONAL, PostgreSQLParserNCHAR, PostgreSQLParserNONE, PostgreSQLParserNULLIF, PostgreSQLParserNUMERIC, PostgreSQLParserOVERLAY, PostgreSQLParserPOSITION, PostgreSQLParserPRECISION, PostgreSQLParserREAL, PostgreSQLParserROW, PostgreSQLParserSETOF, PostgreSQLParserSMALLINT, PostgreSQLParserSUBSTRING, PostgreSQLParserTIME, PostgreSQLParserTIMESTAMP, PostgreSQLParserTREAT, PostgreSQLParserTRIM, PostgreSQLParserVALUES, PostgreSQLParserVARCHAR, PostgreSQLParserXMLATTRIBUTES, PostgreSQLParserXMLCOMMENT, PostgreSQLParserXMLAGG, PostgreSQLParserXML_IS_WELL_FORMED, PostgreSQLParserXML_IS_WELL_FORMED_DOCUMENT, PostgreSQLParserXML_IS_WELL_FORMED_CONTENT, PostgreSQLParserXPATH, PostgreSQLParserXPATH_EXISTS, PostgreSQLParserXMLCONCAT, PostgreSQLParserXMLELEMENT, PostgreSQLParserXMLEXISTS, PostgreSQLParserXMLFOREST, PostgreSQLParserXMLPARSE, PostgreSQLParserXMLPI, PostgreSQLParserXMLROOT, PostgreSQLParserXMLSERIALIZE, PostgreSQLParserCALL, PostgreSQLParserCURRENT_P, PostgreSQLParserATTACH, PostgreSQLParserDETACH, PostgreSQLParserEXPRESSION, PostgreSQLParserGENERATED, PostgreSQLParserLOGGED, PostgreSQLParserSTORED, PostgreSQLParserINCLUDE, PostgreSQLParserROUTINE, PostgreSQLParserTRANSFORM, PostgreSQLParserIMPORT_P, PostgreSQLParserPOLICY, PostgreSQLParserMETHOD, PostgreSQLParserREFERENCING, PostgreSQLParserNEW, PostgreSQLParserOLD, PostgreSQLParserVALUE_P, PostgreSQLParserSUBSCRIPTION, PostgreSQLParserPUBLICATION, PostgreSQLParserOUT_P, PostgreSQLParserROUTINES, PostgreSQLParserSCHEMAS, PostgreSQLParserPROCEDURES, PostgreSQLParserINPUT_P, PostgreSQLParserSUPPORT, PostgreSQLParserPARALLEL, PostgreSQLParserSQL_P, PostgreSQLParserDEPENDS, PostgreSQLParserOVERRIDING, PostgreSQLParserCONFLICT, PostgreSQLParserSKIP_P, PostgreSQLParserLOCKED, PostgreSQLParserTIES, PostgreSQLParserROLLUP, PostgreSQLParserCUBE, PostgreSQLParserGROUPING, PostgreSQLParserSETS, PostgreSQLParserORDINALITY, PostgreSQLParserXMLTABLE, PostgreSQLParserCOLUMNS, PostgreSQLParserXMLNAMESPACES, PostgreSQLParserROWTYPE, PostgreSQLParserNORMALIZED, PostgreSQLParserWITHIN, PostgreSQLParserFILTER, PostgreSQLParserGROUPS, PostgreSQLParserOTHERS, PostgreSQLParserNFC, PostgreSQLParserNFD, PostgreSQLParserNFKC, PostgreSQLParserNFKD, PostgreSQLParserUESCAPE, PostgreSQLParserVIEWS, PostgreSQLParserNORMALIZE, PostgreSQLParserDUMP, PostgreSQLParserPRINT_STRICT_PARAMS, PostgreSQLParserVARIABLE_CONFLICT, PostgreSQLParserERROR, PostgreSQLParserUSE_VARIABLE, PostgreSQLParserUSE_COLUMN, PostgreSQLParserALIAS, PostgreSQLParserCONSTANT, PostgreSQLParserPERFORM, PostgreSQLParserGET, PostgreSQLParserDIAGNOSTICS, PostgreSQLParserSTACKED, PostgreSQLParserELSIF, PostgreSQLParserREVERSE, PostgreSQLParserSLICE, PostgreSQLParserEXIT, PostgreSQLParserRETURN, PostgreSQLParserQUERY, PostgreSQLParserRAISE, PostgreSQLParserSQLSTATE, PostgreSQLParserDEBUG, PostgreSQLParserLOG, PostgreSQLParserINFO, PostgreSQLParserNOTICE, PostgreSQLParserWARNING, PostgreSQLParserEXCEPTION, PostgreSQLParserASSERT, PostgreSQLParserOPEN, PostgreSQLParserABS, PostgreSQLParserCBRT, PostgreSQLParserCEIL, PostgreSQLParserCEILING, PostgreSQLParserDEGREES, PostgreSQLParserDIV, PostgreSQLParserEXP, PostgreSQLParserFACTORIAL, PostgreSQLParserFLOOR, PostgreSQLParserGCD, PostgreSQLParserLCM, PostgreSQLParserLN, PostgreSQLParserLOG10, PostgreSQLParserMIN_SCALE, PostgreSQLParserMOD, PostgreSQLParserPI, PostgreSQLParserPOWER, PostgreSQLParserRADIANS, PostgreSQLParserROUND, PostgreSQLParserSCALE, PostgreSQLParserSIGN, PostgreSQLParserSQRT, PostgreSQLParserTRIM_SCALE, PostgreSQLParserTRUNC, PostgreSQLParserWIDTH_BUCKET, PostgreSQLParserRANDOM, PostgreSQLParserSETSEED, PostgreSQLParserACOS, PostgreSQLParserACOSD, PostgreSQLParserASIN, PostgreSQLParserASIND, PostgreSQLParserATAN, PostgreSQLParserATAND, PostgreSQLParserATAN2, PostgreSQLParserATAN2D, PostgreSQLParserCOS, PostgreSQLParserCOSD, PostgreSQLParserCOT, PostgreSQLParserCOTD, PostgreSQLParserSIN, PostgreSQLParserSIND, PostgreSQLParserTAN, PostgreSQLParserTAND, PostgreSQLParserSINH, PostgreSQLParserCOSH, PostgreSQLParserTANH, PostgreSQLParserASINH, PostgreSQLParserACOSH, PostgreSQLParserATANH, PostgreSQLParserBIT_LENGTH, PostgreSQLParserCHAR_LENGTH, PostgreSQLParserCHARACTER_LENGTH, PostgreSQLParserLOWER, PostgreSQLParserOCTET_LENGTH, PostgreSQLParserUPPER, PostgreSQLParserASCII, PostgreSQLParserBTRIM, PostgreSQLParserCHR, PostgreSQLParserCONCAT, PostgreSQLParserCONCAT_WS, PostgreSQLParserFORMAT, PostgreSQLParserINITCAP, PostgreSQLParserLENGTH, PostgreSQLParserLPAD, PostgreSQLParserLTRIM, PostgreSQLParserMD5, PostgreSQLParserPARSE_IDENT, PostgreSQLParserPG_CLIENT_ENCODING, PostgreSQLParserQUOTE_IDENT, PostgreSQLParserQUOTE_LITERAL, PostgreSQLParserQUOTE_NULLABLE, PostgreSQLParserREGEXP_COUNT, PostgreSQLParserREGEXP_INSTR, PostgreSQLParserREGEXP_LIKE, PostgreSQLParserREGEXP_MATCH, PostgreSQLParserREGEXP_MATCHES, PostgreSQLParserREGEXP_REPLACE, PostgreSQLParserREGEXP_SPLIT_TO_ARRAY, PostgreSQLParserREGEXP_SPLIT_TO_TABLE, PostgreSQLParserREGEXP_SUBSTR, PostgreSQLParserREPEAT, PostgreSQLParserRPAD, PostgreSQLParserRTRIM, PostgreSQLParserSPLIT_PART, PostgreSQLParserSTARTS_WITH, PostgreSQLParserSTRING_TO_ARRAY, PostgreSQLParserSTRING_TO_TABLE, PostgreSQLParserSTRPOS, PostgreSQLParserSUBSTR, PostgreSQLParserTO_ASCII, PostgreSQLParserTO_HEX, PostgreSQLParserTRANSLATE, PostgreSQLParserUNISTR, PostgreSQLParserAGE, PostgreSQLParserCLOCK_TIMESTAMP, PostgreSQLParserDATE_BIN, PostgreSQLParserDATE_PART, PostgreSQLParserDATE_TRUNC, PostgreSQLParserISFINITE, PostgreSQLParserJUSTIFY_DAYS, PostgreSQLParserJUSTIFY_HOURS, PostgreSQLParserJUSTIFY_INTERVAL, PostgreSQLParserMAKE_DATE, PostgreSQLParserMAKE_INTERVAL, PostgreSQLParserMAKE_TIME, PostgreSQLParserMAKE_TIMESTAMP, PostgreSQLParserMAKE_TIMESTAMPTZ, PostgreSQLParserNOW, PostgreSQLParserSTATEMENT_TIMESTAMP, PostgreSQLParserTIMEOFDAY, PostgreSQLParserTRANSACTION_TIMESTAMP, PostgreSQLParserTO_TIMESTAMP, PostgreSQLParserTO_CHAR, PostgreSQLParserTO_DATE, PostgreSQLParserTO_NUMBER, PostgreSQLParserIdentifier, PostgreSQLParserQuotedIdentifier, PostgreSQLParserUnicodeQuotedIdentifier, PostgreSQLParserPLSQLVARIABLENAME, PostgreSQLParserPLSQLIDENTIFIER:
		p.EnterOuterAlt(localctx, 2)

	default:
		p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IGrantstmtContext is an interface to support dynamic dispatch.
type IGrantstmtContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	GRANT() antlr.TerminalNode
	Privileges() IPrivilegesContext
	ON() antlr.TerminalNode
	Privilege_target() IPrivilege_targetContext
	TO() antlr.TerminalNode
	Grantee_list() IGrantee_listContext
	Opt_grant_grant_option() IOpt_grant_grant_optionContext

	// IsGrantstmtContext differentiates from other interfaces.
	IsGrantstmtContext()
}

type GrantstmtContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyGrantstmtContext() *GrantstmtContext {
	var p = new(GrantstmtContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_grantstmt
	return p
}

func InitEmptyGrantstmtContext(p *GrantstmtContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_grantstmt
}

func (*GrantstmtContext) IsGrantstmtContext() {}

func NewGrantstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *GrantstmtContext {
	var p = new(GrantstmtContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_grantstmt

	return p
}

func (s *GrantstmtContext) GetParser() antlr.Parser { return s.parser }

func (s *GrantstmtContext) GRANT() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserGRANT, 0)
}

func (s *GrantstmtContext) Privileges() IPrivilegesContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IPrivilegesContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IPrivilegesContext)
}

func (s *GrantstmtContext) ON() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserON, 0)
}

func (s *GrantstmtContext) Privilege_target() IPrivilege_targetContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IPrivilege_targetContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IPrivilege_targetContext)
}

func (s *GrantstmtContext) TO() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserTO, 0)
}

func (s *GrantstmtContext) Grantee_list() IGrantee_listContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IGrantee_listContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IGrantee_listContext)
}

func (s *GrantstmtContext) Opt_grant_grant_option() IOpt_grant_grant_optionContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOpt_grant_grant_optionContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOpt_grant_grant_optionContext)
}

func (s *GrantstmtContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *GrantstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *GrantstmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterGrantstmt(s)
	}
}

func (s *GrantstmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitGrantstmt(s)
	}
}

func (s *GrantstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitGrantstmt(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Grantstmt() (localctx IGrantstmtContext) {
	localctx = NewGrantstmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 552, PostgreSQLParserRULE_grantstmt)
	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(5002)
		p.Match(PostgreSQLParserGRANT)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(5003)
		p.Privileges()
	}
	{
		p.SetState(5004)
		p.Match(PostgreSQLParserON)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(5005)
		p.Privilege_target()
	}
	{
		p.SetState(5006)
		p.Match(PostgreSQLParserTO)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(5007)
		p.Grantee_list()
	}
	{
		p.SetState(5008)
		p.Opt_grant_grant_option()
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IRevokestmtContext is an interface to support dynamic dispatch.
type IRevokestmtContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	REVOKE() antlr.TerminalNode
	Privileges() IPrivilegesContext
	ON() antlr.TerminalNode
	Privilege_target() IPrivilege_targetContext
	FROM() antlr.TerminalNode
	Grantee_list() IGrantee_listContext
	Opt_drop_behavior() IOpt_drop_behaviorContext
	GRANT() antlr.TerminalNode
	OPTION() antlr.TerminalNode
	FOR() antlr.TerminalNode

	// IsRevokestmtContext differentiates from other interfaces.
	IsRevokestmtContext()
}

type RevokestmtContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyRevokestmtContext() *RevokestmtContext {
	var p = new(RevokestmtContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_revokestmt
	return p
}

func InitEmptyRevokestmtContext(p *RevokestmtContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_revokestmt
}

func (*RevokestmtContext) IsRevokestmtContext() {}

func NewRevokestmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *RevokestmtContext {
	var p = new(RevokestmtContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_revokestmt

	return p
}

func (s *RevokestmtContext) GetParser() antlr.Parser { return s.parser }

func (s *RevokestmtContext) REVOKE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserREVOKE, 0)
}

func (s *RevokestmtContext) Privileges() IPrivilegesContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IPrivilegesContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IPrivilegesContext)
}

func (s *RevokestmtContext) ON() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserON, 0)
}

func (s *RevokestmtContext) Privilege_target() IPrivilege_targetContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IPrivilege_targetContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IPrivilege_targetContext)
}

func (s *RevokestmtContext) FROM() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserFROM, 0)
}

func (s *RevokestmtContext) Grantee_list() IGrantee_listContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IGrantee_listContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IGrantee_listContext)
}

func (s *RevokestmtContext) Opt_drop_behavior() IOpt_drop_behaviorContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOpt_drop_behaviorContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOpt_drop_behaviorContext)
}

func (s *RevokestmtContext) GRANT() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserGRANT, 0)
}

func (s *RevokestmtContext) OPTION() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserOPTION, 0)
}

func (s *RevokestmtContext) FOR() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserFOR, 0)
}

func (s *RevokestmtContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *RevokestmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *RevokestmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterRevokestmt(s)
	}
}

func (s *RevokestmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitRevokestmt(s)
	}
}

func (s *RevokestmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitRevokestmt(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Revokestmt() (localctx IRevokestmtContext) {
	localctx = NewRevokestmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 554, PostgreSQLParserRULE_revokestmt)
	p.SetState(5029)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 235, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(5010)
			p.Match(PostgreSQLParserREVOKE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5011)
			p.Privileges()
		}
		{
			p.SetState(5012)
			p.Match(PostgreSQLParserON)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5013)
			p.Privilege_target()
		}
		{
			p.SetState(5014)
			p.Match(PostgreSQLParserFROM)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5015)
			p.Grantee_list()
		}
		{
			p.SetState(5016)
			p.Opt_drop_behavior()
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(5018)
			p.Match(PostgreSQLParserREVOKE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5019)
			p.Match(PostgreSQLParserGRANT)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5020)
			p.Match(PostgreSQLParserOPTION)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5021)
			p.Match(PostgreSQLParserFOR)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5022)
			p.Privileges()
		}
		{
			p.SetState(5023)
			p.Match(PostgreSQLParserON)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5024)
			p.Privilege_target()
		}
		{
			p.SetState(5025)
			p.Match(PostgreSQLParserFROM)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5026)
			p.Grantee_list()
		}
		{
			p.SetState(5027)
			p.Opt_drop_behavior()
		}

	case antlr.ATNInvalidAltNumber:
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IPrivilegesContext is an interface to support dynamic dispatch.
type IPrivilegesContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Privilege_list() IPrivilege_listContext
	ALL() antlr.TerminalNode
	PRIVILEGES() antlr.TerminalNode
	OPEN_PAREN() antlr.TerminalNode
	Columnlist() IColumnlistContext
	CLOSE_PAREN() antlr.TerminalNode

	// IsPrivilegesContext differentiates from other interfaces.
	IsPrivilegesContext()
}

type PrivilegesContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyPrivilegesContext() *PrivilegesContext {
	var p = new(PrivilegesContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_privileges
	return p
}

func InitEmptyPrivilegesContext(p *PrivilegesContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_privileges
}

func (*PrivilegesContext) IsPrivilegesContext() {}

func NewPrivilegesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *PrivilegesContext {
	var p = new(PrivilegesContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_privileges

	return p
}

func (s *PrivilegesContext) GetParser() antlr.Parser { return s.parser }

func (s *PrivilegesContext) Privilege_list() IPrivilege_listContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IPrivilege_listContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IPrivilege_listContext)
}

func (s *PrivilegesContext) ALL() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserALL, 0)
}

func (s *PrivilegesContext) PRIVILEGES() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserPRIVILEGES, 0)
}

func (s *PrivilegesContext) OPEN_PAREN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserOPEN_PAREN, 0)
}

func (s *PrivilegesContext) Columnlist() IColumnlistContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IColumnlistContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IColumnlistContext)
}

func (s *PrivilegesContext) CLOSE_PAREN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCLOSE_PAREN, 0)
}

func (s *PrivilegesContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *PrivilegesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *PrivilegesContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterPrivileges(s)
	}
}

func (s *PrivilegesContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitPrivileges(s)
	}
}

func (s *PrivilegesContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitPrivileges(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Privileges() (localctx IPrivilegesContext) {
	localctx = NewPrivilegesContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 556, PostgreSQLParserRULE_privileges)
	p.SetState(5046)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 236, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(5031)
			p.Privilege_list()
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(5032)
			p.Match(PostgreSQLParserALL)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 3:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(5033)
			p.Match(PostgreSQLParserALL)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5034)
			p.Match(PostgreSQLParserPRIVILEGES)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 4:
		p.EnterOuterAlt(localctx, 4)
		{
			p.SetState(5035)
			p.Match(PostgreSQLParserALL)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5036)
			p.Match(PostgreSQLParserOPEN_PAREN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5037)
			p.Columnlist()
		}
		{
			p.SetState(5038)
			p.Match(PostgreSQLParserCLOSE_PAREN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 5:
		p.EnterOuterAlt(localctx, 5)
		{
			p.SetState(5040)
			p.Match(PostgreSQLParserALL)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5041)
			p.Match(PostgreSQLParserPRIVILEGES)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5042)
			p.Match(PostgreSQLParserOPEN_PAREN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5043)
			p.Columnlist()
		}
		{
			p.SetState(5044)
			p.Match(PostgreSQLParserCLOSE_PAREN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case antlr.ATNInvalidAltNumber:
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IPrivilege_listContext is an interface to support dynamic dispatch.
type IPrivilege_listContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	AllPrivilege() []IPrivilegeContext
	Privilege(i int) IPrivilegeContext
	AllCOMMA() []antlr.TerminalNode
	COMMA(i int) antlr.TerminalNode

	// IsPrivilege_listContext differentiates from other interfaces.
	IsPrivilege_listContext()
}

type Privilege_listContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyPrivilege_listContext() *Privilege_listContext {
	var p = new(Privilege_listContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_privilege_list
	return p
}

func InitEmptyPrivilege_listContext(p *Privilege_listContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_privilege_list
}

func (*Privilege_listContext) IsPrivilege_listContext() {}

func NewPrivilege_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Privilege_listContext {
	var p = new(Privilege_listContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_privilege_list

	return p
}

func (s *Privilege_listContext) GetParser() antlr.Parser { return s.parser }

func (s *Privilege_listContext) AllPrivilege() []IPrivilegeContext {
	children := s.GetChildren()
	len := 0
	for _, ctx := range children {
		if _, ok := ctx.(IPrivilegeContext); ok {
			len++
		}
	}

	tst := make([]IPrivilegeContext, len)
	i := 0
	for _, ctx := range children {
		if t, ok := ctx.(IPrivilegeContext); ok {
			tst[i] = t.(IPrivilegeContext)
			i++
		}
	}

	return tst
}

func (s *Privilege_listContext) Privilege(i int) IPrivilegeContext {
	var t antlr.RuleContext
	j := 0
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IPrivilegeContext); ok {
			if j == i {
				t = ctx.(antlr.RuleContext)
				break
			}
			j++
		}
	}

	if t == nil {
		return nil
	}

	return t.(IPrivilegeContext)
}

func (s *Privilege_listContext) AllCOMMA() []antlr.TerminalNode {
	return s.GetTokens(PostgreSQLParserCOMMA)
}

func (s *Privilege_listContext) COMMA(i int) antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCOMMA, i)
}

func (s *Privilege_listContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Privilege_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Privilege_listContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterPrivilege_list(s)
	}
}

func (s *Privilege_listContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitPrivilege_list(s)
	}
}

func (s *Privilege_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitPrivilege_list(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Privilege_list() (localctx IPrivilege_listContext) {
	localctx = NewPrivilege_listContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 558, PostgreSQLParserRULE_privilege_list)
	var _la int

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(5048)
		p.Privilege()
	}
	p.SetState(5053)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}
	_la = p.GetTokenStream().LA(1)

	for _la == PostgreSQLParserCOMMA {
		{
			p.SetState(5049)
			p.Match(PostgreSQLParserCOMMA)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5050)
			p.Privilege()
		}

		p.SetState(5055)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}
		_la = p.GetTokenStream().LA(1)
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IPrivilegeContext is an interface to support dynamic dispatch.
type IPrivilegeContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	SELECT() antlr.TerminalNode
	Opt_column_list() IOpt_column_listContext
	REFERENCES() antlr.TerminalNode
	CREATE() antlr.TerminalNode
	Colid() IColidContext

	// IsPrivilegeContext differentiates from other interfaces.
	IsPrivilegeContext()
}

type PrivilegeContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyPrivilegeContext() *PrivilegeContext {
	var p = new(PrivilegeContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_privilege
	return p
}

func InitEmptyPrivilegeContext(p *PrivilegeContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_privilege
}

func (*PrivilegeContext) IsPrivilegeContext() {}

func NewPrivilegeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *PrivilegeContext {
	var p = new(PrivilegeContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_privilege

	return p
}

func (s *PrivilegeContext) GetParser() antlr.Parser { return s.parser }

func (s *PrivilegeContext) SELECT() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserSELECT, 0)
}

func (s *PrivilegeContext) Opt_column_list() IOpt_column_listContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOpt_column_listContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOpt_column_listContext)
}

func (s *PrivilegeContext) REFERENCES() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserREFERENCES, 0)
}

func (s *PrivilegeContext) CREATE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCREATE, 0)
}

func (s *PrivilegeContext) Colid() IColidContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IColidContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IColidContext)
}

func (s *PrivilegeContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *PrivilegeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *PrivilegeContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterPrivilege(s)
	}
}

func (s *PrivilegeContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitPrivilege(s)
	}
}

func (s *PrivilegeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitPrivilege(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Privilege() (localctx IPrivilegeContext) {
	localctx = NewPrivilegeContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 560, PostgreSQLParserRULE_privilege)
	p.SetState(5065)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetTokenStream().LA(1) {
	case PostgreSQLParserSELECT:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(5056)
			p.Match(PostgreSQLParserSELECT)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5057)
			p.Opt_column_list()
		}

	case PostgreSQLParserREFERENCES:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(5058)
			p.Match(PostgreSQLParserREFERENCES)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5059)
			p.Opt_column_list()
		}

	case PostgreSQLParserCREATE:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(5060)
			p.Match(PostgreSQLParserCREATE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5061)
			p.Opt_column_list()
		}

	case PostgreSQLParserAND, PostgreSQLParserARRAY, PostgreSQLParserCOLLATE, PostgreSQLParserCOLUMN, PostgreSQLParserCONSTRAINT, PostgreSQLParserDEFAULT, PostgreSQLParserDO, PostgreSQLParserFETCH, PostgreSQLParserTABLE, PostgreSQLParserIS, PostgreSQLParserLEFT, PostgreSQLParserOUTER_P, PostgreSQLParserOVER, PostgreSQLParserRIGHT, PostgreSQLParserABORT_P, PostgreSQLParserABSOLUTE_P, PostgreSQLParserACCESS, PostgreSQLParserACTION, PostgreSQLParserADD_P, PostgreSQLParserADMIN, PostgreSQLParserAFTER, PostgreSQLParserAGGREGATE, PostgreSQLParserALSO, PostgreSQLParserALTER, PostgreSQLParserALWAYS, PostgreSQLParserASSERTION, PostgreSQLParserASSIGNMENT, PostgreSQLParserAT, PostgreSQLParserATTRIBUTE, PostgreSQLParserBACKWARD, PostgreSQLParserBEFORE, PostgreSQLParserBEGIN_P, PostgreSQLParserBY, PostgreSQLParserCACHE, PostgreSQLParserCALLED, PostgreSQLParserCASCADE, PostgreSQLParserCASCADED, PostgreSQLParserCATALOG, PostgreSQLParserCHAIN, PostgreSQLParserCHARACTERISTICS, PostgreSQLParserCHECKPOINT, PostgreSQLParserCLASS, PostgreSQLParserCLOSE, PostgreSQLParserCLUSTER, PostgreSQLParserCOMMENT, PostgreSQLParserCOMMENTS, PostgreSQLParserCOMMIT, PostgreSQLParserCOMMITTED, PostgreSQLParserCONFIGURATION, PostgreSQLParserCONNECTION, PostgreSQLParserCONSTRAINTS, PostgreSQLParserCONTENT_P, PostgreSQLParserCONTINUE_P, PostgreSQLParserCONVERSION_P, PostgreSQLParserCOPY, PostgreSQLParserCOST, PostgreSQLParserCSV, PostgreSQLParserCURSOR, PostgreSQLParserCYCLE, PostgreSQLParserDATA_P, PostgreSQLParserDATABASE, PostgreSQLParserDAY_P, PostgreSQLParserDEALLOCATE, PostgreSQLParserDECLARE, PostgreSQLParserDEFAULTS, PostgreSQLParserDEFERRED, PostgreSQLParserDEFINER, PostgreSQLParserDELETE_P, PostgreSQLParserDELIMITER, PostgreSQLParserDELIMITERS, PostgreSQLParserDICTIONARY, PostgreSQLParserDISABLE_P, PostgreSQLParserDISCARD, PostgreSQLParserDOCUMENT_P, PostgreSQLParserDOMAIN_P, PostgreSQLParserDOUBLE_P, PostgreSQLParserDROP, PostgreSQLParserEACH, PostgreSQLParserENABLE_P, PostgreSQLParserENCODING, PostgreSQLParserENCRYPTED, PostgreSQLParserENUM_P, PostgreSQLParserESCAPE, PostgreSQLParserEVENT, PostgreSQLParserEXCLUDE, PostgreSQLParserEXCLUDING, PostgreSQLParserEXCLUSIVE, PostgreSQLParserEXECUTE, PostgreSQLParserEXPLAIN, PostgreSQLParserEXTENSION, PostgreSQLParserEXTERNAL, PostgreSQLParserFAMILY, PostgreSQLParserFIRST_P, PostgreSQLParserFOLLOWING, PostgreSQLParserFORCE, PostgreSQLParserFORWARD, PostgreSQLParserFUNCTION, PostgreSQLParserFUNCTIONS, PostgreSQLParserGLOBAL, PostgreSQLParserGRANTED, PostgreSQLParserHANDLER, PostgreSQLParserHEADER_P, PostgreSQLParserHOLD, PostgreSQLParserHOUR_P, PostgreSQLParserIDENTITY_P, PostgreSQLParserIF_P, PostgreSQLParserIMMEDIATE, PostgreSQLParserIMMUTABLE, PostgreSQLParserIMPLICIT_P, PostgreSQLParserINCLUDING, PostgreSQLParserINCREMENT, PostgreSQLParserINDEX, PostgreSQLParserINDEXES, PostgreSQLParserINHERIT, PostgreSQLParserINHERITS, PostgreSQLParserINLINE_P, PostgreSQLParserINSENSITIVE, PostgreSQLParserINSERT, PostgreSQLParserINSTEAD, PostgreSQLParserINVOKER, PostgreSQLParserISOLATION, PostgreSQLParserKEY, PostgreSQLParserLABEL, PostgreSQLParserLANGUAGE, PostgreSQLParserLARGE_P, PostgreSQLParserLAST_P, PostgreSQLParserLEAKPROOF, PostgreSQLParserLEVEL, PostgreSQLParserLISTEN, PostgreSQLParserLOAD, PostgreSQLParserLOCAL, PostgreSQLParserLOCATION, PostgreSQLParserLOCK_P, PostgreSQLParserMAPPING, PostgreSQLParserMATCH, PostgreSQLParserMATERIALIZED, PostgreSQLParserMAXVALUE, PostgreSQLParserMINUTE_P, PostgreSQLParserMINVALUE, PostgreSQLParserMODE, PostgreSQLParserMONTH_P, PostgreSQLParserMOVE, PostgreSQLParserNAME_P, PostgreSQLParserNAMES, PostgreSQLParserNEXT, PostgreSQLParserNO, PostgreSQLParserNOTHING, PostgreSQLParserNOTIFY, PostgreSQLParserNOWAIT, PostgreSQLParserNULLS_P, PostgreSQLParserOBJECT_P, PostgreSQLParserOF, PostgreSQLParserOFF, PostgreSQLParserOIDS, PostgreSQLParserOPERATOR, PostgreSQLParserOPTION, PostgreSQLParserOPTIONS, PostgreSQLParserOWNED, PostgreSQLParserOWNER, PostgreSQLParserPARSER, PostgreSQLParserPARTIAL, PostgreSQLParserPARTITION, PostgreSQLParserPASSING, PostgreSQLParserPASSWORD, PostgreSQLParserPLANS, PostgreSQLParserPRECEDING, PostgreSQLParserPREPARE, PostgreSQLParserPREPARED, PostgreSQLParserPRESERVE, PostgreSQLParserPRIOR, PostgreSQLParserPRIVILEGES, PostgreSQLParserPROCEDURAL, PostgreSQLParserPROCEDURE, PostgreSQLParserPROGRAM, PostgreSQLParserQUOTE, PostgreSQLParserRANGE, PostgreSQLParserREAD, PostgreSQLParserREASSIGN, PostgreSQLParserRECHECK, PostgreSQLParserRECURSIVE, PostgreSQLParserREF, PostgreSQLParserREFRESH, PostgreSQLParserREINDEX, PostgreSQLParserRELATIVE_P, PostgreSQLParserRELEASE, PostgreSQLParserRENAME, PostgreSQLParserREPEATABLE, PostgreSQLParserREPLACE, PostgreSQLParserREPLICA, PostgreSQLParserRESET, PostgreSQLParserRESTART, PostgreSQLParserRESTRICT, PostgreSQLParserRETURNS, PostgreSQLParserREVOKE, PostgreSQLParserROLE, PostgreSQLParserROLLBACK, PostgreSQLParserROWS, PostgreSQLParserRULE, PostgreSQLParserSAVEPOINT, PostgreSQLParserSCHEMA, PostgreSQLParserSCROLL, PostgreSQLParserSEARCH, PostgreSQLParserSECOND_P, PostgreSQLParserSECURITY, PostgreSQLParserSEQUENCE, PostgreSQLParserSEQUENCES, PostgreSQLParserSERIALIZABLE, PostgreSQLParserSERVER, PostgreSQLParserSESSION, PostgreSQLParserSET, PostgreSQLParserSHARE, PostgreSQLParserSHOW, PostgreSQLParserSIMPLE, PostgreSQLParserSNAPSHOT, PostgreSQLParserSTABLE, PostgreSQLParserSTANDALONE_P, PostgreSQLParserSTART, PostgreSQLParserSTATEMENT, PostgreSQLParserSTATISTICS, PostgreSQLParserSTDIN, PostgreSQLParserSTDOUT, PostgreSQLParserSTORAGE, PostgreSQLParserSTRICT_P, PostgreSQLParserSTRIP_P, PostgreSQLParserSYSID, PostgreSQLParserSYSTEM_P, PostgreSQLParserTABLES, PostgreSQLParserTABLESPACE, PostgreSQLParserTEMP, PostgreSQLParserTEMPLATE, PostgreSQLParserTEMPORARY, PostgreSQLParserTEXT_P, PostgreSQLParserTRANSACTION, PostgreSQLParserTRIGGER, PostgreSQLParserTRUNCATE, PostgreSQLParserTRUSTED, PostgreSQLParserTYPE_P, PostgreSQLParserTYPES_P, PostgreSQLParserUNBOUNDED, PostgreSQLParserUNCOMMITTED, PostgreSQLParserUNENCRYPTED, PostgreSQLParserUNKNOWN, PostgreSQLParserUNLISTEN, PostgreSQLParserUNLOGGED, PostgreSQLParserUNTIL, PostgreSQLParserUPDATE, PostgreSQLParserVACUUM, PostgreSQLParserVALID, PostgreSQLParserVALIDATE, PostgreSQLParserVALIDATOR, PostgreSQLParserVARYING, PostgreSQLParserVERSION_P, PostgreSQLParserVIEW, PostgreSQLParserVOLATILE, PostgreSQLParserWHITESPACE_P, PostgreSQLParserWITHOUT, PostgreSQLParserWORK, PostgreSQLParserWRAPPER, PostgreSQLParserWRITE, PostgreSQLParserXML_P, PostgreSQLParserYEAR_P, PostgreSQLParserYES_P, PostgreSQLParserZONE, PostgreSQLParserBETWEEN, PostgreSQLParserBIGINT, PostgreSQLParserBIT, PostgreSQLParserBOOLEAN_P, PostgreSQLParserCHAR_P, PostgreSQLParserCHARACTER, PostgreSQLParserCOALESCE, PostgreSQLParserDEC, PostgreSQLParserDECIMAL_P, PostgreSQLParserEXISTS, PostgreSQLParserEXTRACT, PostgreSQLParserFLOAT_P, PostgreSQLParserGREATEST, PostgreSQLParserINOUT, PostgreSQLParserINT_P, PostgreSQLParserINTEGER, PostgreSQLParserINTERVAL, PostgreSQLParserLEAST, PostgreSQLParserNATIONAL, PostgreSQLParserNCHAR, PostgreSQLParserNONE, PostgreSQLParserNULLIF, PostgreSQLParserNUMERIC, PostgreSQLParserOVERLAY, PostgreSQLParserPOSITION, PostgreSQLParserPRECISION, PostgreSQLParserREAL, PostgreSQLParserROW, PostgreSQLParserSETOF, PostgreSQLParserSMALLINT, PostgreSQLParserSUBSTRING, PostgreSQLParserTIME, PostgreSQLParserTIMESTAMP, PostgreSQLParserTREAT, PostgreSQLParserTRIM, PostgreSQLParserVALUES, PostgreSQLParserVARCHAR, PostgreSQLParserXMLATTRIBUTES, PostgreSQLParserXMLCOMMENT, PostgreSQLParserXMLAGG, PostgreSQLParserXML_IS_WELL_FORMED, PostgreSQLParserXML_IS_WELL_FORMED_DOCUMENT, PostgreSQLParserXML_IS_WELL_FORMED_CONTENT, PostgreSQLParserXPATH, PostgreSQLParserXPATH_EXISTS, PostgreSQLParserXMLCONCAT, PostgreSQLParserXMLELEMENT, PostgreSQLParserXMLEXISTS, PostgreSQLParserXMLFOREST, PostgreSQLParserXMLPARSE, PostgreSQLParserXMLPI, PostgreSQLParserXMLROOT, PostgreSQLParserXMLSERIALIZE, PostgreSQLParserCALL, PostgreSQLParserCURRENT_P, PostgreSQLParserATTACH, PostgreSQLParserDETACH, PostgreSQLParserEXPRESSION, PostgreSQLParserGENERATED, PostgreSQLParserLOGGED, PostgreSQLParserSTORED, PostgreSQLParserINCLUDE, PostgreSQLParserROUTINE, PostgreSQLParserTRANSFORM, PostgreSQLParserIMPORT_P, PostgreSQLParserPOLICY, PostgreSQLParserMETHOD, PostgreSQLParserREFERENCING, PostgreSQLParserNEW, PostgreSQLParserOLD, PostgreSQLParserVALUE_P, PostgreSQLParserSUBSCRIPTION, PostgreSQLParserPUBLICATION, PostgreSQLParserOUT_P, PostgreSQLParserROUTINES, PostgreSQLParserSCHEMAS, PostgreSQLParserPROCEDURES, PostgreSQLParserINPUT_P, PostgreSQLParserSUPPORT, PostgreSQLParserPARALLEL, PostgreSQLParserSQL_P, PostgreSQLParserDEPENDS, PostgreSQLParserOVERRIDING, PostgreSQLParserCONFLICT, PostgreSQLParserSKIP_P, PostgreSQLParserLOCKED, PostgreSQLParserTIES, PostgreSQLParserROLLUP, PostgreSQLParserCUBE, PostgreSQLParserGROUPING, PostgreSQLParserSETS, PostgreSQLParserORDINALITY, PostgreSQLParserXMLTABLE, PostgreSQLParserCOLUMNS, PostgreSQLParserXMLNAMESPACES, PostgreSQLParserROWTYPE, PostgreSQLParserNORMALIZED, PostgreSQLParserWITHIN, PostgreSQLParserFILTER, PostgreSQLParserGROUPS, PostgreSQLParserOTHERS, PostgreSQLParserNFC, PostgreSQLParserNFD, PostgreSQLParserNFKC, PostgreSQLParserNFKD, PostgreSQLParserUESCAPE, PostgreSQLParserVIEWS, PostgreSQLParserNORMALIZE, PostgreSQLParserDUMP, PostgreSQLParserPRINT_STRICT_PARAMS, PostgreSQLParserVARIABLE_CONFLICT, PostgreSQLParserERROR, PostgreSQLParserUSE_VARIABLE, PostgreSQLParserUSE_COLUMN, PostgreSQLParserALIAS, PostgreSQLParserCONSTANT, PostgreSQLParserPERFORM, PostgreSQLParserGET, PostgreSQLParserDIAGNOSTICS, PostgreSQLParserSTACKED, PostgreSQLParserELSIF, PostgreSQLParserREVERSE, PostgreSQLParserSLICE, PostgreSQLParserEXIT, PostgreSQLParserRETURN, PostgreSQLParserQUERY, PostgreSQLParserRAISE, PostgreSQLParserSQLSTATE, PostgreSQLParserDEBUG, PostgreSQLParserLOG, PostgreSQLParserINFO, PostgreSQLParserNOTICE, PostgreSQLParserWARNING, PostgreSQLParserEXCEPTION, PostgreSQLParserASSERT, PostgreSQLParserOPEN, PostgreSQLParserABS, PostgreSQLParserCBRT, PostgreSQLParserCEIL, PostgreSQLParserCEILING, PostgreSQLParserDEGREES, PostgreSQLParserDIV, PostgreSQLParserEXP, PostgreSQLParserFACTORIAL, PostgreSQLParserFLOOR, PostgreSQLParserGCD, PostgreSQLParserLCM, PostgreSQLParserLN, PostgreSQLParserLOG10, PostgreSQLParserMIN_SCALE, PostgreSQLParserMOD, PostgreSQLParserPI, PostgreSQLParserPOWER, PostgreSQLParserRADIANS, PostgreSQLParserROUND, PostgreSQLParserSCALE, PostgreSQLParserSIGN, PostgreSQLParserSQRT, PostgreSQLParserTRIM_SCALE, PostgreSQLParserTRUNC, PostgreSQLParserWIDTH_BUCKET, PostgreSQLParserRANDOM, PostgreSQLParserSETSEED, PostgreSQLParserACOS, PostgreSQLParserACOSD, PostgreSQLParserASIN, PostgreSQLParserASIND, PostgreSQLParserATAN, PostgreSQLParserATAND, PostgreSQLParserATAN2, PostgreSQLParserATAN2D, PostgreSQLParserCOS, PostgreSQLParserCOSD, PostgreSQLParserCOT, PostgreSQLParserCOTD, PostgreSQLParserSIN, PostgreSQLParserSIND, PostgreSQLParserTAN, PostgreSQLParserTAND, PostgreSQLParserSINH, PostgreSQLParserCOSH, PostgreSQLParserTANH, PostgreSQLParserASINH, PostgreSQLParserACOSH, PostgreSQLParserATANH, PostgreSQLParserBIT_LENGTH, PostgreSQLParserCHAR_LENGTH, PostgreSQLParserCHARACTER_LENGTH, PostgreSQLParserLOWER, PostgreSQLParserOCTET_LENGTH, PostgreSQLParserUPPER, PostgreSQLParserASCII, PostgreSQLParserBTRIM, PostgreSQLParserCHR, PostgreSQLParserCONCAT, PostgreSQLParserCONCAT_WS, PostgreSQLParserFORMAT, PostgreSQLParserINITCAP, PostgreSQLParserLENGTH, PostgreSQLParserLPAD, PostgreSQLParserLTRIM, PostgreSQLParserMD5, PostgreSQLParserPARSE_IDENT, PostgreSQLParserPG_CLIENT_ENCODING, PostgreSQLParserQUOTE_IDENT, PostgreSQLParserQUOTE_LITERAL, PostgreSQLParserQUOTE_NULLABLE, PostgreSQLParserREGEXP_COUNT, PostgreSQLParserREGEXP_INSTR, PostgreSQLParserREGEXP_LIKE, PostgreSQLParserREGEXP_MATCH, PostgreSQLParserREGEXP_MATCHES, PostgreSQLParserREGEXP_REPLACE, PostgreSQLParserREGEXP_SPLIT_TO_ARRAY, PostgreSQLParserREGEXP_SPLIT_TO_TABLE, PostgreSQLParserREGEXP_SUBSTR, PostgreSQLParserREPEAT, PostgreSQLParserRPAD, PostgreSQLParserRTRIM, PostgreSQLParserSPLIT_PART, PostgreSQLParserSTARTS_WITH, PostgreSQLParserSTRING_TO_ARRAY, PostgreSQLParserSTRING_TO_TABLE, PostgreSQLParserSTRPOS, PostgreSQLParserSUBSTR, PostgreSQLParserTO_ASCII, PostgreSQLParserTO_HEX, PostgreSQLParserTRANSLATE, PostgreSQLParserUNISTR, PostgreSQLParserAGE, PostgreSQLParserCLOCK_TIMESTAMP, PostgreSQLParserDATE_BIN, PostgreSQLParserDATE_PART, PostgreSQLParserDATE_TRUNC, PostgreSQLParserISFINITE, PostgreSQLParserJUSTIFY_DAYS, PostgreSQLParserJUSTIFY_HOURS, PostgreSQLParserJUSTIFY_INTERVAL, PostgreSQLParserMAKE_DATE, PostgreSQLParserMAKE_INTERVAL, PostgreSQLParserMAKE_TIME, PostgreSQLParserMAKE_TIMESTAMP, PostgreSQLParserMAKE_TIMESTAMPTZ, PostgreSQLParserNOW, PostgreSQLParserSTATEMENT_TIMESTAMP, PostgreSQLParserTIMEOFDAY, PostgreSQLParserTRANSACTION_TIMESTAMP, PostgreSQLParserTO_TIMESTAMP, PostgreSQLParserTO_CHAR, PostgreSQLParserTO_DATE, PostgreSQLParserTO_NUMBER, PostgreSQLParserIdentifier, PostgreSQLParserQuotedIdentifier, PostgreSQLParserUnicodeQuotedIdentifier, PostgreSQLParserPLSQLVARIABLENAME, PostgreSQLParserPLSQLIDENTIFIER:
		p.EnterOuterAlt(localctx, 4)
		{
			p.SetState(5062)
			p.Colid()
		}
		{
			p.SetState(5063)
			p.Opt_column_list()
		}

	default:
		p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IPrivilege_targetContext is an interface to support dynamic dispatch.
type IPrivilege_targetContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Qualified_name_list() IQualified_name_listContext
	TABLE() antlr.TerminalNode
	SEQUENCE() antlr.TerminalNode
	FOREIGN() antlr.TerminalNode
	DATA_P() antlr.TerminalNode
	WRAPPER() antlr.TerminalNode
	Name_list() IName_listContext
	SERVER() antlr.TerminalNode
	FUNCTION() antlr.TerminalNode
	Function_with_argtypes_list() IFunction_with_argtypes_listContext
	PROCEDURE() antlr.TerminalNode
	ROUTINE() antlr.TerminalNode
	DATABASE() antlr.TerminalNode
	DOMAIN_P() antlr.TerminalNode
	Any_name_list() IAny_name_listContext
	LANGUAGE() antlr.TerminalNode
	LARGE_P() antlr.TerminalNode
	OBJECT_P() antlr.TerminalNode
	Numericonly_list() INumericonly_listContext
	SCHEMA() antlr.TerminalNode
	TABLESPACE() antlr.TerminalNode
	TYPE_P() antlr.TerminalNode
	ALL() antlr.TerminalNode
	TABLES() antlr.TerminalNode
	IN_P() antlr.TerminalNode
	SEQUENCES() antlr.TerminalNode
	FUNCTIONS() antlr.TerminalNode
	PROCEDURES() antlr.TerminalNode
	ROUTINES() antlr.TerminalNode

	// IsPrivilege_targetContext differentiates from other interfaces.
	IsPrivilege_targetContext()
}

type Privilege_targetContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyPrivilege_targetContext() *Privilege_targetContext {
	var p = new(Privilege_targetContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_privilege_target
	return p
}

func InitEmptyPrivilege_targetContext(p *Privilege_targetContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_privilege_target
}

func (*Privilege_targetContext) IsPrivilege_targetContext() {}

func NewPrivilege_targetContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Privilege_targetContext {
	var p = new(Privilege_targetContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_privilege_target

	return p
}

func (s *Privilege_targetContext) GetParser() antlr.Parser { return s.parser }

func (s *Privilege_targetContext) Qualified_name_list() IQualified_name_listContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IQualified_name_listContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IQualified_name_listContext)
}

func (s *Privilege_targetContext) TABLE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserTABLE, 0)
}

func (s *Privilege_targetContext) SEQUENCE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserSEQUENCE, 0)
}

func (s *Privilege_targetContext) FOREIGN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserFOREIGN, 0)
}

func (s *Privilege_targetContext) DATA_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserDATA_P, 0)
}

func (s *Privilege_targetContext) WRAPPER() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserWRAPPER, 0)
}

func (s *Privilege_targetContext) Name_list() IName_listContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IName_listContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IName_listContext)
}

func (s *Privilege_targetContext) SERVER() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserSERVER, 0)
}

func (s *Privilege_targetContext) FUNCTION() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserFUNCTION, 0)
}

func (s *Privilege_targetContext) Function_with_argtypes_list() IFunction_with_argtypes_listContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IFunction_with_argtypes_listContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IFunction_with_argtypes_listContext)
}

func (s *Privilege_targetContext) PROCEDURE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserPROCEDURE, 0)
}

func (s *Privilege_targetContext) ROUTINE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserROUTINE, 0)
}

func (s *Privilege_targetContext) DATABASE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserDATABASE, 0)
}

func (s *Privilege_targetContext) DOMAIN_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserDOMAIN_P, 0)
}

func (s *Privilege_targetContext) Any_name_list() IAny_name_listContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IAny_name_listContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IAny_name_listContext)
}

func (s *Privilege_targetContext) LANGUAGE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserLANGUAGE, 0)
}

func (s *Privilege_targetContext) LARGE_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserLARGE_P, 0)
}

func (s *Privilege_targetContext) OBJECT_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserOBJECT_P, 0)
}

func (s *Privilege_targetContext) Numericonly_list() INumericonly_listContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(INumericonly_listContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(INumericonly_listContext)
}

func (s *Privilege_targetContext) SCHEMA() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserSCHEMA, 0)
}

func (s *Privilege_targetContext) TABLESPACE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserTABLESPACE, 0)
}

func (s *Privilege_targetContext) TYPE_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserTYPE_P, 0)
}

func (s *Privilege_targetContext) ALL() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserALL, 0)
}

func (s *Privilege_targetContext) TABLES() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserTABLES, 0)
}

func (s *Privilege_targetContext) IN_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserIN_P, 0)
}

func (s *Privilege_targetContext) SEQUENCES() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserSEQUENCES, 0)
}

func (s *Privilege_targetContext) FUNCTIONS() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserFUNCTIONS, 0)
}

func (s *Privilege_targetContext) PROCEDURES() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserPROCEDURES, 0)
}

func (s *Privilege_targetContext) ROUTINES() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserROUTINES, 0)
}

func (s *Privilege_targetContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Privilege_targetContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Privilege_targetContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterPrivilege_target(s)
	}
}

func (s *Privilege_targetContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitPrivilege_target(s)
	}
}

func (s *Privilege_targetContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitPrivilege_target(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Privilege_target() (localctx IPrivilege_targetContext) {
	localctx = NewPrivilege_targetContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 562, PostgreSQLParserRULE_privilege_target)
	p.SetState(5125)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 239, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(5067)
			p.Qualified_name_list()
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(5068)
			p.Match(PostgreSQLParserTABLE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5069)
			p.Qualified_name_list()
		}

	case 3:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(5070)
			p.Match(PostgreSQLParserSEQUENCE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5071)
			p.Qualified_name_list()
		}

	case 4:
		p.EnterOuterAlt(localctx, 4)
		{
			p.SetState(5072)
			p.Match(PostgreSQLParserFOREIGN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5073)
			p.Match(PostgreSQLParserDATA_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5074)
			p.Match(PostgreSQLParserWRAPPER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5075)
			p.Name_list()
		}

	case 5:
		p.EnterOuterAlt(localctx, 5)
		{
			p.SetState(5076)
			p.Match(PostgreSQLParserFOREIGN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5077)
			p.Match(PostgreSQLParserSERVER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5078)
			p.Name_list()
		}

	case 6:
		p.EnterOuterAlt(localctx, 6)
		{
			p.SetState(5079)
			p.Match(PostgreSQLParserFUNCTION)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5080)
			p.Function_with_argtypes_list()
		}

	case 7:
		p.EnterOuterAlt(localctx, 7)
		{
			p.SetState(5081)
			p.Match(PostgreSQLParserPROCEDURE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5082)
			p.Function_with_argtypes_list()
		}

	case 8:
		p.EnterOuterAlt(localctx, 8)
		{
			p.SetState(5083)
			p.Match(PostgreSQLParserROUTINE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5084)
			p.Function_with_argtypes_list()
		}

	case 9:
		p.EnterOuterAlt(localctx, 9)
		{
			p.SetState(5085)
			p.Match(PostgreSQLParserDATABASE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5086)
			p.Name_list()
		}

	case 10:
		p.EnterOuterAlt(localctx, 10)
		{
			p.SetState(5087)
			p.Match(PostgreSQLParserDOMAIN_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5088)
			p.Any_name_list()
		}

	case 11:
		p.EnterOuterAlt(localctx, 11)
		{
			p.SetState(5089)
			p.Match(PostgreSQLParserLANGUAGE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5090)
			p.Name_list()
		}

	case 12:
		p.EnterOuterAlt(localctx, 12)
		{
			p.SetState(5091)
			p.Match(PostgreSQLParserLARGE_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5092)
			p.Match(PostgreSQLParserOBJECT_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5093)
			p.Numericonly_list()
		}

	case 13:
		p.EnterOuterAlt(localctx, 13)
		{
			p.SetState(5094)
			p.Match(PostgreSQLParserSCHEMA)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5095)
			p.Name_list()
		}

	case 14:
		p.EnterOuterAlt(localctx, 14)
		{
			p.SetState(5096)
			p.Match(PostgreSQLParserTABLESPACE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5097)
			p.Name_list()
		}

	case 15:
		p.EnterOuterAlt(localctx, 15)
		{
			p.SetState(5098)
			p.Match(PostgreSQLParserTYPE_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5099)
			p.Any_name_list()
		}

	case 16:
		p.EnterOuterAlt(localctx, 16)
		{
			p.SetState(5100)
			p.Match(PostgreSQLParserALL)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5101)
			p.Match(PostgreSQLParserTABLES)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5102)
			p.Match(PostgreSQLParserIN_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5103)
			p.Match(PostgreSQLParserSCHEMA)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5104)
			p.Name_list()
		}

	case 17:
		p.EnterOuterAlt(localctx, 17)
		{
			p.SetState(5105)
			p.Match(PostgreSQLParserALL)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5106)
			p.Match(PostgreSQLParserSEQUENCES)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5107)
			p.Match(PostgreSQLParserIN_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5108)
			p.Match(PostgreSQLParserSCHEMA)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5109)
			p.Name_list()
		}

	case 18:
		p.EnterOuterAlt(localctx, 18)
		{
			p.SetState(5110)
			p.Match(PostgreSQLParserALL)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5111)
			p.Match(PostgreSQLParserFUNCTIONS)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5112)
			p.Match(PostgreSQLParserIN_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5113)
			p.Match(PostgreSQLParserSCHEMA)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5114)
			p.Name_list()
		}

	case 19:
		p.EnterOuterAlt(localctx, 19)
		{
			p.SetState(5115)
			p.Match(PostgreSQLParserALL)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5116)
			p.Match(PostgreSQLParserPROCEDURES)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5117)
			p.Match(PostgreSQLParserIN_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5118)
			p.Match(PostgreSQLParserSCHEMA)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5119)
			p.Name_list()
		}

	case 20:
		p.EnterOuterAlt(localctx, 20)
		{
			p.SetState(5120)
			p.Match(PostgreSQLParserALL)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5121)
			p.Match(PostgreSQLParserROUTINES)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5122)
			p.Match(PostgreSQLParserIN_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5123)
			p.Match(PostgreSQLParserSCHEMA)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5124)
			p.Name_list()
		}

	case antlr.ATNInvalidAltNumber:
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IGrantee_listContext is an interface to support dynamic dispatch.
type IGrantee_listContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	AllGrantee() []IGranteeContext
	Grantee(i int) IGranteeContext
	AllCOMMA() []antlr.TerminalNode
	COMMA(i int) antlr.TerminalNode

	// IsGrantee_listContext differentiates from other interfaces.
	IsGrantee_listContext()
}

type Grantee_listContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyGrantee_listContext() *Grantee_listContext {
	var p = new(Grantee_listContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_grantee_list
	return p
}

func InitEmptyGrantee_listContext(p *Grantee_listContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_grantee_list
}

func (*Grantee_listContext) IsGrantee_listContext() {}

func NewGrantee_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Grantee_listContext {
	var p = new(Grantee_listContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_grantee_list

	return p
}

func (s *Grantee_listContext) GetParser() antlr.Parser { return s.parser }

func (s *Grantee_listContext) AllGrantee() []IGranteeContext {
	children := s.GetChildren()
	len := 0
	for _, ctx := range children {
		if _, ok := ctx.(IGranteeContext); ok {
			len++
		}
	}

	tst := make([]IGranteeContext, len)
	i := 0
	for _, ctx := range children {
		if t, ok := ctx.(IGranteeContext); ok {
			tst[i] = t.(IGranteeContext)
			i++
		}
	}

	return tst
}

func (s *Grantee_listContext) Grantee(i int) IGranteeContext {
	var t antlr.RuleContext
	j := 0
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IGranteeContext); ok {
			if j == i {
				t = ctx.(antlr.RuleContext)
				break
			}
			j++
		}
	}

	if t == nil {
		return nil
	}

	return t.(IGranteeContext)
}

func (s *Grantee_listContext) AllCOMMA() []antlr.TerminalNode {
	return s.GetTokens(PostgreSQLParserCOMMA)
}

func (s *Grantee_listContext) COMMA(i int) antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCOMMA, i)
}

func (s *Grantee_listContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Grantee_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Grantee_listContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterGrantee_list(s)
	}
}

func (s *Grantee_listContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitGrantee_list(s)
	}
}

func (s *Grantee_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitGrantee_list(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Grantee_list() (localctx IGrantee_listContext) {
	localctx = NewGrantee_listContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 564, PostgreSQLParserRULE_grantee_list)
	var _la int

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(5127)
		p.Grantee()
	}
	p.SetState(5132)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}
	_la = p.GetTokenStream().LA(1)

	for _la == PostgreSQLParserCOMMA {
		{
			p.SetState(5128)
			p.Match(PostgreSQLParserCOMMA)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5129)
			p.Grantee()
		}

		p.SetState(5134)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}
		_la = p.GetTokenStream().LA(1)
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IGranteeContext is an interface to support dynamic dispatch.
type IGranteeContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Rolespec() IRolespecContext
	GROUP_P() antlr.TerminalNode

	// IsGranteeContext differentiates from other interfaces.
	IsGranteeContext()
}

type GranteeContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyGranteeContext() *GranteeContext {
	var p = new(GranteeContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_grantee
	return p
}

func InitEmptyGranteeContext(p *GranteeContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_grantee
}

func (*GranteeContext) IsGranteeContext() {}

func NewGranteeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *GranteeContext {
	var p = new(GranteeContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_grantee

	return p
}

func (s *GranteeContext) GetParser() antlr.Parser { return s.parser }

func (s *GranteeContext) Rolespec() IRolespecContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IRolespecContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IRolespecContext)
}

func (s *GranteeContext) GROUP_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserGROUP_P, 0)
}

func (s *GranteeContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *GranteeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *GranteeContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterGrantee(s)
	}
}

func (s *GranteeContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitGrantee(s)
	}
}

func (s *GranteeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitGrantee(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Grantee() (localctx IGranteeContext) {
	localctx = NewGranteeContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 566, PostgreSQLParserRULE_grantee)
	p.SetState(5138)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetTokenStream().LA(1) {
	case PostgreSQLParserAND, PostgreSQLParserARRAY, PostgreSQLParserCOLLATE, PostgreSQLParserCOLUMN, PostgreSQLParserCONSTRAINT, PostgreSQLParserCURRENT_USER, PostgreSQLParserDEFAULT, PostgreSQLParserDO, PostgreSQLParserFETCH, PostgreSQLParserSESSION_USER, PostgreSQLParserTABLE, PostgreSQLParserAUTHORIZATION, PostgreSQLParserBINARY, PostgreSQLParserCOLLATION, PostgreSQLParserCONCURRENTLY, PostgreSQLParserCROSS, PostgreSQLParserCURRENT_SCHEMA, PostgreSQLParserFREEZE, PostgreSQLParserFULL, PostgreSQLParserILIKE, PostgreSQLParserINNER_P, PostgreSQLParserIS, PostgreSQLParserISNULL, PostgreSQLParserJOIN, PostgreSQLParserLIKE, PostgreSQLParserNATURAL, PostgreSQLParserNOTNULL, PostgreSQLParserOUTER_P, PostgreSQLParserOVER, PostgreSQLParserOVERLAPS, PostgreSQLParserSIMILAR, PostgreSQLParserVERBOSE, PostgreSQLParserABORT_P, PostgreSQLParserABSOLUTE_P, PostgreSQLParserACCESS, PostgreSQLParserACTION, PostgreSQLParserADD_P, PostgreSQLParserADMIN, PostgreSQLParserAFTER, PostgreSQLParserAGGREGATE, PostgreSQLParserALSO, PostgreSQLParserALTER, PostgreSQLParserALWAYS, PostgreSQLParserASSERTION, PostgreSQLParserASSIGNMENT, PostgreSQLParserAT, PostgreSQLParserATTRIBUTE, PostgreSQLParserBACKWARD, PostgreSQLParserBEFORE, PostgreSQLParserBEGIN_P, PostgreSQLParserBY, PostgreSQLParserCACHE, PostgreSQLParserCALLED, PostgreSQLParserCASCADE, PostgreSQLParserCASCADED, PostgreSQLParserCATALOG, PostgreSQLParserCHAIN, PostgreSQLParserCHARACTERISTICS, PostgreSQLParserCHECKPOINT, PostgreSQLParserCLASS, PostgreSQLParserCLOSE, PostgreSQLParserCLUSTER, PostgreSQLParserCOMMENT, PostgreSQLParserCOMMENTS, PostgreSQLParserCOMMIT, PostgreSQLParserCOMMITTED, PostgreSQLParserCONFIGURATION, PostgreSQLParserCONNECTION, PostgreSQLParserCONSTRAINTS, PostgreSQLParserCONTENT_P, PostgreSQLParserCONTINUE_P, PostgreSQLParserCONVERSION_P, PostgreSQLParserCOPY, PostgreSQLParserCOST, PostgreSQLParserCSV, PostgreSQLParserCURSOR, PostgreSQLParserCYCLE, PostgreSQLParserDATA_P, PostgreSQLParserDATABASE, PostgreSQLParserDAY_P, PostgreSQLParserDEALLOCATE, PostgreSQLParserDECLARE, PostgreSQLParserDEFAULTS, PostgreSQLParserDEFERRED, PostgreSQLParserDEFINER, PostgreSQLParserDELETE_P, PostgreSQLParserDELIMITER, PostgreSQLParserDELIMITERS, PostgreSQLParserDICTIONARY, PostgreSQLParserDISABLE_P, PostgreSQLParserDISCARD, PostgreSQLParserDOCUMENT_P, PostgreSQLParserDOMAIN_P, PostgreSQLParserDOUBLE_P, PostgreSQLParserDROP, PostgreSQLParserEACH, PostgreSQLParserENABLE_P, PostgreSQLParserENCODING, PostgreSQLParserENCRYPTED, PostgreSQLParserENUM_P, PostgreSQLParserESCAPE, PostgreSQLParserEVENT, PostgreSQLParserEXCLUDE, PostgreSQLParserEXCLUDING, PostgreSQLParserEXCLUSIVE, PostgreSQLParserEXECUTE, PostgreSQLParserEXPLAIN, PostgreSQLParserEXTENSION, PostgreSQLParserEXTERNAL, PostgreSQLParserFAMILY, PostgreSQLParserFIRST_P, PostgreSQLParserFOLLOWING, PostgreSQLParserFORCE, PostgreSQLParserFORWARD, PostgreSQLParserFUNCTION, PostgreSQLParserFUNCTIONS, PostgreSQLParserGLOBAL, PostgreSQLParserGRANTED, PostgreSQLParserHANDLER, PostgreSQLParserHEADER_P, PostgreSQLParserHOLD, PostgreSQLParserHOUR_P, PostgreSQLParserIDENTITY_P, PostgreSQLParserIF_P, PostgreSQLParserIMMEDIATE, PostgreSQLParserIMMUTABLE, PostgreSQLParserIMPLICIT_P, PostgreSQLParserINCLUDING, PostgreSQLParserINCREMENT, PostgreSQLParserINDEX, PostgreSQLParserINDEXES, PostgreSQLParserINHERIT, PostgreSQLParserINHERITS, PostgreSQLParserINLINE_P, PostgreSQLParserINSENSITIVE, PostgreSQLParserINSERT, PostgreSQLParserINSTEAD, PostgreSQLParserINVOKER, PostgreSQLParserISOLATION, PostgreSQLParserKEY, PostgreSQLParserLABEL, PostgreSQLParserLANGUAGE, PostgreSQLParserLARGE_P, PostgreSQLParserLAST_P, PostgreSQLParserLEAKPROOF, PostgreSQLParserLEVEL, PostgreSQLParserLISTEN, PostgreSQLParserLOAD, PostgreSQLParserLOCAL, PostgreSQLParserLOCATION, PostgreSQLParserLOCK_P, PostgreSQLParserMAPPING, PostgreSQLParserMATCH, PostgreSQLParserMATERIALIZED, PostgreSQLParserMAXVALUE, PostgreSQLParserMINUTE_P, PostgreSQLParserMINVALUE, PostgreSQLParserMODE, PostgreSQLParserMONTH_P, PostgreSQLParserMOVE, PostgreSQLParserNAME_P, PostgreSQLParserNAMES, PostgreSQLParserNEXT, PostgreSQLParserNO, PostgreSQLParserNOTHING, PostgreSQLParserNOTIFY, PostgreSQLParserNOWAIT, PostgreSQLParserNULLS_P, PostgreSQLParserOBJECT_P, PostgreSQLParserOF, PostgreSQLParserOFF, PostgreSQLParserOIDS, PostgreSQLParserOPERATOR, PostgreSQLParserOPTION, PostgreSQLParserOPTIONS, PostgreSQLParserOWNED, PostgreSQLParserOWNER, PostgreSQLParserPARSER, PostgreSQLParserPARTIAL, PostgreSQLParserPARTITION, PostgreSQLParserPASSING, PostgreSQLParserPASSWORD, PostgreSQLParserPLANS, PostgreSQLParserPRECEDING, PostgreSQLParserPREPARE, PostgreSQLParserPREPARED, PostgreSQLParserPRESERVE, PostgreSQLParserPRIOR, PostgreSQLParserPRIVILEGES, PostgreSQLParserPROCEDURAL, PostgreSQLParserPROCEDURE, PostgreSQLParserPROGRAM, PostgreSQLParserQUOTE, PostgreSQLParserRANGE, PostgreSQLParserREAD, PostgreSQLParserREASSIGN, PostgreSQLParserRECHECK, PostgreSQLParserRECURSIVE, PostgreSQLParserREF, PostgreSQLParserREFRESH, PostgreSQLParserREINDEX, PostgreSQLParserRELATIVE_P, PostgreSQLParserRELEASE, PostgreSQLParserRENAME, PostgreSQLParserREPEATABLE, PostgreSQLParserREPLACE, PostgreSQLParserREPLICA, PostgreSQLParserRESET, PostgreSQLParserRESTART, PostgreSQLParserRESTRICT, PostgreSQLParserRETURNS, PostgreSQLParserREVOKE, PostgreSQLParserROLE, PostgreSQLParserROLLBACK, PostgreSQLParserROWS, PostgreSQLParserRULE, PostgreSQLParserSAVEPOINT, PostgreSQLParserSCHEMA, PostgreSQLParserSCROLL, PostgreSQLParserSEARCH, PostgreSQLParserSECOND_P, PostgreSQLParserSECURITY, PostgreSQLParserSEQUENCE, PostgreSQLParserSEQUENCES, PostgreSQLParserSERIALIZABLE, PostgreSQLParserSERVER, PostgreSQLParserSESSION, PostgreSQLParserSET, PostgreSQLParserSHARE, PostgreSQLParserSHOW, PostgreSQLParserSIMPLE, PostgreSQLParserSNAPSHOT, PostgreSQLParserSTABLE, PostgreSQLParserSTANDALONE_P, PostgreSQLParserSTART, PostgreSQLParserSTATEMENT, PostgreSQLParserSTATISTICS, PostgreSQLParserSTDIN, PostgreSQLParserSTDOUT, PostgreSQLParserSTORAGE, PostgreSQLParserSTRICT_P, PostgreSQLParserSTRIP_P, PostgreSQLParserSYSID, PostgreSQLParserSYSTEM_P, PostgreSQLParserTABLES, PostgreSQLParserTABLESPACE, PostgreSQLParserTEMP, PostgreSQLParserTEMPLATE, PostgreSQLParserTEMPORARY, PostgreSQLParserTEXT_P, PostgreSQLParserTRANSACTION, PostgreSQLParserTRIGGER, PostgreSQLParserTRUNCATE, PostgreSQLParserTRUSTED, PostgreSQLParserTYPE_P, PostgreSQLParserTYPES_P, PostgreSQLParserUNBOUNDED, PostgreSQLParserUNCOMMITTED, PostgreSQLParserUNENCRYPTED, PostgreSQLParserUNKNOWN, PostgreSQLParserUNLISTEN, PostgreSQLParserUNLOGGED, PostgreSQLParserUNTIL, PostgreSQLParserUPDATE, PostgreSQLParserVACUUM, PostgreSQLParserVALID, PostgreSQLParserVALIDATE, PostgreSQLParserVALIDATOR, PostgreSQLParserVARYING, PostgreSQLParserVERSION_P, PostgreSQLParserVIEW, PostgreSQLParserVOLATILE, PostgreSQLParserWHITESPACE_P, PostgreSQLParserWITHOUT, PostgreSQLParserWORK, PostgreSQLParserWRAPPER, PostgreSQLParserWRITE, PostgreSQLParserXML_P, PostgreSQLParserYEAR_P, PostgreSQLParserYES_P, PostgreSQLParserZONE, PostgreSQLParserBETWEEN, PostgreSQLParserBIGINT, PostgreSQLParserBIT, PostgreSQLParserBOOLEAN_P, PostgreSQLParserCHAR_P, PostgreSQLParserCHARACTER, PostgreSQLParserCOALESCE, PostgreSQLParserDEC, PostgreSQLParserDECIMAL_P, PostgreSQLParserEXISTS, PostgreSQLParserEXTRACT, PostgreSQLParserFLOAT_P, PostgreSQLParserGREATEST, PostgreSQLParserINOUT, PostgreSQLParserINT_P, PostgreSQLParserINTEGER, PostgreSQLParserINTERVAL, PostgreSQLParserLEAST, PostgreSQLParserNATIONAL, PostgreSQLParserNCHAR, PostgreSQLParserNONE, PostgreSQLParserNULLIF, PostgreSQLParserNUMERIC, PostgreSQLParserOVERLAY, PostgreSQLParserPOSITION, PostgreSQLParserPRECISION, PostgreSQLParserREAL, PostgreSQLParserROW, PostgreSQLParserSETOF, PostgreSQLParserSMALLINT, PostgreSQLParserSUBSTRING, PostgreSQLParserTIME, PostgreSQLParserTIMESTAMP, PostgreSQLParserTREAT, PostgreSQLParserTRIM, PostgreSQLParserVALUES, PostgreSQLParserVARCHAR, PostgreSQLParserXMLATTRIBUTES, PostgreSQLParserXMLCOMMENT, PostgreSQLParserXMLAGG, PostgreSQLParserXML_IS_WELL_FORMED, PostgreSQLParserXML_IS_WELL_FORMED_DOCUMENT, PostgreSQLParserXML_IS_WELL_FORMED_CONTENT, PostgreSQLParserXPATH, PostgreSQLParserXPATH_EXISTS, PostgreSQLParserXMLCONCAT, PostgreSQLParserXMLELEMENT, PostgreSQLParserXMLEXISTS, PostgreSQLParserXMLFOREST, PostgreSQLParserXMLPARSE, PostgreSQLParserXMLPI, PostgreSQLParserXMLROOT, PostgreSQLParserXMLSERIALIZE, PostgreSQLParserCALL, PostgreSQLParserCURRENT_P, PostgreSQLParserATTACH, PostgreSQLParserDETACH, PostgreSQLParserEXPRESSION, PostgreSQLParserGENERATED, PostgreSQLParserLOGGED, PostgreSQLParserSTORED, PostgreSQLParserINCLUDE, PostgreSQLParserROUTINE, PostgreSQLParserTRANSFORM, PostgreSQLParserIMPORT_P, PostgreSQLParserPOLICY, PostgreSQLParserMETHOD, PostgreSQLParserREFERENCING, PostgreSQLParserNEW, PostgreSQLParserOLD, PostgreSQLParserVALUE_P, PostgreSQLParserSUBSCRIPTION, PostgreSQLParserPUBLICATION, PostgreSQLParserOUT_P, PostgreSQLParserROUTINES, PostgreSQLParserSCHEMAS, PostgreSQLParserPROCEDURES, PostgreSQLParserINPUT_P, PostgreSQLParserSUPPORT, PostgreSQLParserPARALLEL, PostgreSQLParserSQL_P, PostgreSQLParserDEPENDS, PostgreSQLParserOVERRIDING, PostgreSQLParserCONFLICT, PostgreSQLParserSKIP_P, PostgreSQLParserLOCKED, PostgreSQLParserTIES, PostgreSQLParserROLLUP, PostgreSQLParserCUBE, PostgreSQLParserGROUPING, PostgreSQLParserSETS, PostgreSQLParserTABLESAMPLE, PostgreSQLParserORDINALITY, PostgreSQLParserXMLTABLE, PostgreSQLParserCOLUMNS, PostgreSQLParserXMLNAMESPACES, PostgreSQLParserROWTYPE, PostgreSQLParserNORMALIZED, PostgreSQLParserWITHIN, PostgreSQLParserFILTER, PostgreSQLParserGROUPS, PostgreSQLParserOTHERS, PostgreSQLParserNFC, PostgreSQLParserNFD, PostgreSQLParserNFKC, PostgreSQLParserNFKD, PostgreSQLParserUESCAPE, PostgreSQLParserVIEWS, PostgreSQLParserNORMALIZE, PostgreSQLParserDUMP, PostgreSQLParserPRINT_STRICT_PARAMS, PostgreSQLParserVARIABLE_CONFLICT, PostgreSQLParserERROR, PostgreSQLParserUSE_VARIABLE, PostgreSQLParserUSE_COLUMN, PostgreSQLParserALIAS, PostgreSQLParserCONSTANT, PostgreSQLParserPERFORM, PostgreSQLParserGET, PostgreSQLParserDIAGNOSTICS, PostgreSQLParserSTACKED, PostgreSQLParserELSIF, PostgreSQLParserREVERSE, PostgreSQLParserSLICE, PostgreSQLParserEXIT, PostgreSQLParserRETURN, PostgreSQLParserQUERY, PostgreSQLParserRAISE, PostgreSQLParserSQLSTATE, PostgreSQLParserDEBUG, PostgreSQLParserLOG, PostgreSQLParserINFO, PostgreSQLParserNOTICE, PostgreSQLParserWARNING, PostgreSQLParserEXCEPTION, PostgreSQLParserASSERT, PostgreSQLParserOPEN, PostgreSQLParserABS, PostgreSQLParserCBRT, PostgreSQLParserCEIL, PostgreSQLParserCEILING, PostgreSQLParserDEGREES, PostgreSQLParserDIV, PostgreSQLParserEXP, PostgreSQLParserFACTORIAL, PostgreSQLParserFLOOR, PostgreSQLParserGCD, PostgreSQLParserLCM, PostgreSQLParserLN, PostgreSQLParserLOG10, PostgreSQLParserMIN_SCALE, PostgreSQLParserMOD, PostgreSQLParserPI, PostgreSQLParserPOWER, PostgreSQLParserRADIANS, PostgreSQLParserROUND, PostgreSQLParserSCALE, PostgreSQLParserSIGN, PostgreSQLParserSQRT, PostgreSQLParserTRIM_SCALE, PostgreSQLParserTRUNC, PostgreSQLParserWIDTH_BUCKET, PostgreSQLParserRANDOM, PostgreSQLParserSETSEED, PostgreSQLParserACOS, PostgreSQLParserACOSD, PostgreSQLParserASIN, PostgreSQLParserASIND, PostgreSQLParserATAN, PostgreSQLParserATAND, PostgreSQLParserATAN2, PostgreSQLParserATAN2D, PostgreSQLParserCOS, PostgreSQLParserCOSD, PostgreSQLParserCOT, PostgreSQLParserCOTD, PostgreSQLParserSIN, PostgreSQLParserSIND, PostgreSQLParserTAN, PostgreSQLParserTAND, PostgreSQLParserSINH, PostgreSQLParserCOSH, PostgreSQLParserTANH, PostgreSQLParserASINH, PostgreSQLParserACOSH, PostgreSQLParserATANH, PostgreSQLParserBIT_LENGTH, PostgreSQLParserCHAR_LENGTH, PostgreSQLParserCHARACTER_LENGTH, PostgreSQLParserLOWER, PostgreSQLParserOCTET_LENGTH, PostgreSQLParserUPPER, PostgreSQLParserASCII, PostgreSQLParserBTRIM, PostgreSQLParserCHR, PostgreSQLParserCONCAT, PostgreSQLParserCONCAT_WS, PostgreSQLParserFORMAT, PostgreSQLParserINITCAP, PostgreSQLParserLENGTH, PostgreSQLParserLPAD, PostgreSQLParserLTRIM, PostgreSQLParserMD5, PostgreSQLParserPARSE_IDENT, PostgreSQLParserPG_CLIENT_ENCODING, PostgreSQLParserQUOTE_IDENT, PostgreSQLParserQUOTE_LITERAL, PostgreSQLParserQUOTE_NULLABLE, PostgreSQLParserREGEXP_COUNT, PostgreSQLParserREGEXP_INSTR, PostgreSQLParserREGEXP_LIKE, PostgreSQLParserREGEXP_MATCH, PostgreSQLParserREGEXP_MATCHES, PostgreSQLParserREGEXP_REPLACE, PostgreSQLParserREGEXP_SPLIT_TO_ARRAY, PostgreSQLParserREGEXP_SPLIT_TO_TABLE, PostgreSQLParserREGEXP_SUBSTR, PostgreSQLParserREPEAT, PostgreSQLParserRPAD, PostgreSQLParserRTRIM, PostgreSQLParserSPLIT_PART, PostgreSQLParserSTARTS_WITH, PostgreSQLParserSTRING_TO_ARRAY, PostgreSQLParserSTRING_TO_TABLE, PostgreSQLParserSTRPOS, PostgreSQLParserSUBSTR, PostgreSQLParserTO_ASCII, PostgreSQLParserTO_HEX, PostgreSQLParserTRANSLATE, PostgreSQLParserUNISTR, PostgreSQLParserAGE, PostgreSQLParserCLOCK_TIMESTAMP, PostgreSQLParserDATE_BIN, PostgreSQLParserDATE_PART, PostgreSQLParserDATE_TRUNC, PostgreSQLParserISFINITE, PostgreSQLParserJUSTIFY_DAYS, PostgreSQLParserJUSTIFY_HOURS, PostgreSQLParserJUSTIFY_INTERVAL, PostgreSQLParserMAKE_DATE, PostgreSQLParserMAKE_INTERVAL, PostgreSQLParserMAKE_TIME, PostgreSQLParserMAKE_TIMESTAMP, PostgreSQLParserMAKE_TIMESTAMPTZ, PostgreSQLParserNOW, PostgreSQLParserSTATEMENT_TIMESTAMP, PostgreSQLParserTIMEOFDAY, PostgreSQLParserTRANSACTION_TIMESTAMP, PostgreSQLParserTO_TIMESTAMP, PostgreSQLParserTO_CHAR, PostgreSQLParserTO_DATE, PostgreSQLParserTO_NUMBER, PostgreSQLParserIdentifier, PostgreSQLParserQuotedIdentifier, PostgreSQLParserUnicodeQuotedIdentifier, PostgreSQLParserPLSQLVARIABLENAME, PostgreSQLParserPLSQLIDENTIFIER:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(5135)
			p.Rolespec()
		}

	case PostgreSQLParserGROUP_P:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(5136)
			p.Match(PostgreSQLParserGROUP_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5137)
			p.Rolespec()
		}

	default:
		p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IOpt_grant_grant_optionContext is an interface to support dynamic dispatch.
type IOpt_grant_grant_optionContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	WITH() antlr.TerminalNode
	GRANT() antlr.TerminalNode
	OPTION() antlr.TerminalNode

	// IsOpt_grant_grant_optionContext differentiates from other interfaces.
	IsOpt_grant_grant_optionContext()
}

type Opt_grant_grant_optionContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyOpt_grant_grant_optionContext() *Opt_grant_grant_optionContext {
	var p = new(Opt_grant_grant_optionContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opt_grant_grant_option
	return p
}

func InitEmptyOpt_grant_grant_optionContext(p *Opt_grant_grant_optionContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opt_grant_grant_option
}

func (*Opt_grant_grant_optionContext) IsOpt_grant_grant_optionContext() {}

func NewOpt_grant_grant_optionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_grant_grant_optionContext {
	var p = new(Opt_grant_grant_optionContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_opt_grant_grant_option

	return p
}

func (s *Opt_grant_grant_optionContext) GetParser() antlr.Parser { return s.parser }

func (s *Opt_grant_grant_optionContext) WITH() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserWITH, 0)
}

func (s *Opt_grant_grant_optionContext) GRANT() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserGRANT, 0)
}

func (s *Opt_grant_grant_optionContext) OPTION() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserOPTION, 0)
}

func (s *Opt_grant_grant_optionContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Opt_grant_grant_optionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Opt_grant_grant_optionContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterOpt_grant_grant_option(s)
	}
}

func (s *Opt_grant_grant_optionContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitOpt_grant_grant_option(s)
	}
}

func (s *Opt_grant_grant_optionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitOpt_grant_grant_option(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Opt_grant_grant_option() (localctx IOpt_grant_grant_optionContext) {
	localctx = NewOpt_grant_grant_optionContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 568, PostgreSQLParserRULE_opt_grant_grant_option)
	p.SetState(5144)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 242, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(5140)
			p.Match(PostgreSQLParserWITH)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5141)
			p.Match(PostgreSQLParserGRANT)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5142)
			p.Match(PostgreSQLParserOPTION)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)

	case antlr.ATNInvalidAltNumber:
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IGrantrolestmtContext is an interface to support dynamic dispatch.
type IGrantrolestmtContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	GRANT() antlr.TerminalNode
	Privilege_list() IPrivilege_listContext
	TO() antlr.TerminalNode
	Role_list() IRole_listContext
	Opt_grant_admin_option() IOpt_grant_admin_optionContext
	Opt_granted_by() IOpt_granted_byContext

	// IsGrantrolestmtContext differentiates from other interfaces.
	IsGrantrolestmtContext()
}

type GrantrolestmtContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyGrantrolestmtContext() *GrantrolestmtContext {
	var p = new(GrantrolestmtContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_grantrolestmt
	return p
}

func InitEmptyGrantrolestmtContext(p *GrantrolestmtContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_grantrolestmt
}

func (*GrantrolestmtContext) IsGrantrolestmtContext() {}

func NewGrantrolestmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *GrantrolestmtContext {
	var p = new(GrantrolestmtContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_grantrolestmt

	return p
}

func (s *GrantrolestmtContext) GetParser() antlr.Parser { return s.parser }

func (s *GrantrolestmtContext) GRANT() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserGRANT, 0)
}

func (s *GrantrolestmtContext) Privilege_list() IPrivilege_listContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IPrivilege_listContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IPrivilege_listContext)
}

func (s *GrantrolestmtContext) TO() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserTO, 0)
}

func (s *GrantrolestmtContext) Role_list() IRole_listContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IRole_listContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IRole_listContext)
}

func (s *GrantrolestmtContext) Opt_grant_admin_option() IOpt_grant_admin_optionContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOpt_grant_admin_optionContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOpt_grant_admin_optionContext)
}

func (s *GrantrolestmtContext) Opt_granted_by() IOpt_granted_byContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOpt_granted_byContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOpt_granted_byContext)
}

func (s *GrantrolestmtContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *GrantrolestmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *GrantrolestmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterGrantrolestmt(s)
	}
}

func (s *GrantrolestmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitGrantrolestmt(s)
	}
}

func (s *GrantrolestmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitGrantrolestmt(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Grantrolestmt() (localctx IGrantrolestmtContext) {
	localctx = NewGrantrolestmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 570, PostgreSQLParserRULE_grantrolestmt)
	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(5146)
		p.Match(PostgreSQLParserGRANT)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(5147)
		p.Privilege_list()
	}
	{
		p.SetState(5148)
		p.Match(PostgreSQLParserTO)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(5149)
		p.Role_list()
	}
	{
		p.SetState(5150)
		p.Opt_grant_admin_option()
	}
	{
		p.SetState(5151)
		p.Opt_granted_by()
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IRevokerolestmtContext is an interface to support dynamic dispatch.
type IRevokerolestmtContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	REVOKE() antlr.TerminalNode
	Privilege_list() IPrivilege_listContext
	FROM() antlr.TerminalNode
	Role_list() IRole_listContext
	Opt_granted_by() IOpt_granted_byContext
	Opt_drop_behavior() IOpt_drop_behaviorContext
	ADMIN() antlr.TerminalNode
	OPTION() antlr.TerminalNode
	FOR() antlr.TerminalNode

	// IsRevokerolestmtContext differentiates from other interfaces.
	IsRevokerolestmtContext()
}

type RevokerolestmtContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyRevokerolestmtContext() *RevokerolestmtContext {
	var p = new(RevokerolestmtContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_revokerolestmt
	return p
}

func InitEmptyRevokerolestmtContext(p *RevokerolestmtContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_revokerolestmt
}

func (*RevokerolestmtContext) IsRevokerolestmtContext() {}

func NewRevokerolestmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *RevokerolestmtContext {
	var p = new(RevokerolestmtContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_revokerolestmt

	return p
}

func (s *RevokerolestmtContext) GetParser() antlr.Parser { return s.parser }

func (s *RevokerolestmtContext) REVOKE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserREVOKE, 0)
}

func (s *RevokerolestmtContext) Privilege_list() IPrivilege_listContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IPrivilege_listContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IPrivilege_listContext)
}

func (s *RevokerolestmtContext) FROM() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserFROM, 0)
}

func (s *RevokerolestmtContext) Role_list() IRole_listContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IRole_listContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IRole_listContext)
}

func (s *RevokerolestmtContext) Opt_granted_by() IOpt_granted_byContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOpt_granted_byContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOpt_granted_byContext)
}

func (s *RevokerolestmtContext) Opt_drop_behavior() IOpt_drop_behaviorContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOpt_drop_behaviorContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOpt_drop_behaviorContext)
}

func (s *RevokerolestmtContext) ADMIN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserADMIN, 0)
}

func (s *RevokerolestmtContext) OPTION() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserOPTION, 0)
}

func (s *RevokerolestmtContext) FOR() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserFOR, 0)
}

func (s *RevokerolestmtContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *RevokerolestmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *RevokerolestmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterRevokerolestmt(s)
	}
}

func (s *RevokerolestmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitRevokerolestmt(s)
	}
}

func (s *RevokerolestmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitRevokerolestmt(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Revokerolestmt() (localctx IRevokerolestmtContext) {
	localctx = NewRevokerolestmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 572, PostgreSQLParserRULE_revokerolestmt)
	p.SetState(5170)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 243, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(5153)
			p.Match(PostgreSQLParserREVOKE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5154)
			p.Privilege_list()
		}
		{
			p.SetState(5155)
			p.Match(PostgreSQLParserFROM)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5156)
			p.Role_list()
		}
		{
			p.SetState(5157)
			p.Opt_granted_by()
		}
		{
			p.SetState(5158)
			p.Opt_drop_behavior()
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(5160)
			p.Match(PostgreSQLParserREVOKE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5161)
			p.Match(PostgreSQLParserADMIN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5162)
			p.Match(PostgreSQLParserOPTION)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5163)
			p.Match(PostgreSQLParserFOR)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5164)
			p.Privilege_list()
		}
		{
			p.SetState(5165)
			p.Match(PostgreSQLParserFROM)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5166)
			p.Role_list()
		}
		{
			p.SetState(5167)
			p.Opt_granted_by()
		}
		{
			p.SetState(5168)
			p.Opt_drop_behavior()
		}

	case antlr.ATNInvalidAltNumber:
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IOpt_grant_admin_optionContext is an interface to support dynamic dispatch.
type IOpt_grant_admin_optionContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	WITH() antlr.TerminalNode
	ADMIN() antlr.TerminalNode
	OPTION() antlr.TerminalNode

	// IsOpt_grant_admin_optionContext differentiates from other interfaces.
	IsOpt_grant_admin_optionContext()
}

type Opt_grant_admin_optionContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyOpt_grant_admin_optionContext() *Opt_grant_admin_optionContext {
	var p = new(Opt_grant_admin_optionContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opt_grant_admin_option
	return p
}

func InitEmptyOpt_grant_admin_optionContext(p *Opt_grant_admin_optionContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opt_grant_admin_option
}

func (*Opt_grant_admin_optionContext) IsOpt_grant_admin_optionContext() {}

func NewOpt_grant_admin_optionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_grant_admin_optionContext {
	var p = new(Opt_grant_admin_optionContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_opt_grant_admin_option

	return p
}

func (s *Opt_grant_admin_optionContext) GetParser() antlr.Parser { return s.parser }

func (s *Opt_grant_admin_optionContext) WITH() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserWITH, 0)
}

func (s *Opt_grant_admin_optionContext) ADMIN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserADMIN, 0)
}

func (s *Opt_grant_admin_optionContext) OPTION() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserOPTION, 0)
}

func (s *Opt_grant_admin_optionContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Opt_grant_admin_optionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Opt_grant_admin_optionContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterOpt_grant_admin_option(s)
	}
}

func (s *Opt_grant_admin_optionContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitOpt_grant_admin_option(s)
	}
}

func (s *Opt_grant_admin_optionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitOpt_grant_admin_option(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Opt_grant_admin_option() (localctx IOpt_grant_admin_optionContext) {
	localctx = NewOpt_grant_admin_optionContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 574, PostgreSQLParserRULE_opt_grant_admin_option)
	p.SetState(5176)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 244, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(5172)
			p.Match(PostgreSQLParserWITH)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5173)
			p.Match(PostgreSQLParserADMIN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5174)
			p.Match(PostgreSQLParserOPTION)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)

	case antlr.ATNInvalidAltNumber:
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IOpt_granted_byContext is an interface to support dynamic dispatch.
type IOpt_granted_byContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	GRANTED() antlr.TerminalNode
	BY() antlr.TerminalNode
	Rolespec() IRolespecContext

	// IsOpt_granted_byContext differentiates from other interfaces.
	IsOpt_granted_byContext()
}

type Opt_granted_byContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyOpt_granted_byContext() *Opt_granted_byContext {
	var p = new(Opt_granted_byContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opt_granted_by
	return p
}

func InitEmptyOpt_granted_byContext(p *Opt_granted_byContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opt_granted_by
}

func (*Opt_granted_byContext) IsOpt_granted_byContext() {}

func NewOpt_granted_byContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_granted_byContext {
	var p = new(Opt_granted_byContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_opt_granted_by

	return p
}

func (s *Opt_granted_byContext) GetParser() antlr.Parser { return s.parser }

func (s *Opt_granted_byContext) GRANTED() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserGRANTED, 0)
}

func (s *Opt_granted_byContext) BY() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserBY, 0)
}

func (s *Opt_granted_byContext) Rolespec() IRolespecContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IRolespecContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IRolespecContext)
}

func (s *Opt_granted_byContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Opt_granted_byContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Opt_granted_byContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterOpt_granted_by(s)
	}
}

func (s *Opt_granted_byContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitOpt_granted_by(s)
	}
}

func (s *Opt_granted_byContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitOpt_granted_by(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Opt_granted_by() (localctx IOpt_granted_byContext) {
	localctx = NewOpt_granted_byContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 576, PostgreSQLParserRULE_opt_granted_by)
	p.SetState(5182)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetTokenStream().LA(1) {
	case PostgreSQLParserGRANTED:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(5178)
			p.Match(PostgreSQLParserGRANTED)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5179)
			p.Match(PostgreSQLParserBY)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5180)
			p.Rolespec()
		}

	case PostgreSQLParserEOF, PostgreSQLParserOPEN_PAREN, PostgreSQLParserSEMI, PostgreSQLParserANALYSE, PostgreSQLParserANALYZE, PostgreSQLParserCREATE, PostgreSQLParserDO, PostgreSQLParserFETCH, PostgreSQLParserGRANT, PostgreSQLParserINTO, PostgreSQLParserSELECT, PostgreSQLParserTABLE, PostgreSQLParserWITH, PostgreSQLParserABORT_P, PostgreSQLParserALTER, PostgreSQLParserBEGIN_P, PostgreSQLParserCASCADE, PostgreSQLParserCHECKPOINT, PostgreSQLParserCLOSE, PostgreSQLParserCLUSTER, PostgreSQLParserCOMMENT, PostgreSQLParserCOMMIT, PostgreSQLParserCOPY, PostgreSQLParserDEALLOCATE, PostgreSQLParserDECLARE, PostgreSQLParserDELETE_P, PostgreSQLParserDISCARD, PostgreSQLParserDROP, PostgreSQLParserEXECUTE, PostgreSQLParserEXPLAIN, PostgreSQLParserINSERT, PostgreSQLParserLISTEN, PostgreSQLParserLOAD, PostgreSQLParserLOCK_P, PostgreSQLParserMERGE, PostgreSQLParserMOVE, PostgreSQLParserNOTIFY, PostgreSQLParserPREPARE, PostgreSQLParserREASSIGN, PostgreSQLParserREFRESH, PostgreSQLParserREINDEX, PostgreSQLParserRELEASE, PostgreSQLParserRESET, PostgreSQLParserRESTRICT, PostgreSQLParserREVOKE, PostgreSQLParserROLLBACK, PostgreSQLParserSAVEPOINT, PostgreSQLParserSECURITY, PostgreSQLParserSET, PostgreSQLParserSHOW, PostgreSQLParserSTART, PostgreSQLParserTRUNCATE, PostgreSQLParserUNLISTEN, PostgreSQLParserUPDATE, PostgreSQLParserVACUUM, PostgreSQLParserVALUES, PostgreSQLParserCALL, PostgreSQLParserIMPORT_P, PostgreSQLParserEND_P, PostgreSQLParserMetaCommand:
		p.EnterOuterAlt(localctx, 2)

	default:
		p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IAlterdefaultprivilegesstmtContext is an interface to support dynamic dispatch.
type IAlterdefaultprivilegesstmtContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	ALTER() antlr.TerminalNode
	DEFAULT() antlr.TerminalNode
	PRIVILEGES() antlr.TerminalNode
	Defacloptionlist() IDefacloptionlistContext
	Defaclaction() IDefaclactionContext

	// IsAlterdefaultprivilegesstmtContext differentiates from other interfaces.
	IsAlterdefaultprivilegesstmtContext()
}

type AlterdefaultprivilegesstmtContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyAlterdefaultprivilegesstmtContext() *AlterdefaultprivilegesstmtContext {
	var p = new(AlterdefaultprivilegesstmtContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_alterdefaultprivilegesstmt
	return p
}

func InitEmptyAlterdefaultprivilegesstmtContext(p *AlterdefaultprivilegesstmtContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_alterdefaultprivilegesstmt
}

func (*AlterdefaultprivilegesstmtContext) IsAlterdefaultprivilegesstmtContext() {}

func NewAlterdefaultprivilegesstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AlterdefaultprivilegesstmtContext {
	var p = new(AlterdefaultprivilegesstmtContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_alterdefaultprivilegesstmt

	return p
}

func (s *AlterdefaultprivilegesstmtContext) GetParser() antlr.Parser { return s.parser }

func (s *AlterdefaultprivilegesstmtContext) ALTER() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserALTER, 0)
}

func (s *AlterdefaultprivilegesstmtContext) DEFAULT() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserDEFAULT, 0)
}

func (s *AlterdefaultprivilegesstmtContext) PRIVILEGES() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserPRIVILEGES, 0)
}

func (s *AlterdefaultprivilegesstmtContext) Defacloptionlist() IDefacloptionlistContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IDefacloptionlistContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IDefacloptionlistContext)
}

func (s *AlterdefaultprivilegesstmtContext) Defaclaction() IDefaclactionContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IDefaclactionContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IDefaclactionContext)
}

func (s *AlterdefaultprivilegesstmtContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *AlterdefaultprivilegesstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *AlterdefaultprivilegesstmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterAlterdefaultprivilegesstmt(s)
	}
}

func (s *AlterdefaultprivilegesstmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitAlterdefaultprivilegesstmt(s)
	}
}

func (s *AlterdefaultprivilegesstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitAlterdefaultprivilegesstmt(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Alterdefaultprivilegesstmt() (localctx IAlterdefaultprivilegesstmtContext) {
	localctx = NewAlterdefaultprivilegesstmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 578, PostgreSQLParserRULE_alterdefaultprivilegesstmt)
	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(5184)
		p.Match(PostgreSQLParserALTER)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(5185)
		p.Match(PostgreSQLParserDEFAULT)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(5186)
		p.Match(PostgreSQLParserPRIVILEGES)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(5187)
		p.Defacloptionlist()
	}
	{
		p.SetState(5188)
		p.Defaclaction()
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IDefacloptionlistContext is an interface to support dynamic dispatch.
type IDefacloptionlistContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	AllDefacloption() []IDefacloptionContext
	Defacloption(i int) IDefacloptionContext

	// IsDefacloptionlistContext differentiates from other interfaces.
	IsDefacloptionlistContext()
}

type DefacloptionlistContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyDefacloptionlistContext() *DefacloptionlistContext {
	var p = new(DefacloptionlistContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_defacloptionlist
	return p
}

func InitEmptyDefacloptionlistContext(p *DefacloptionlistContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_defacloptionlist
}

func (*DefacloptionlistContext) IsDefacloptionlistContext() {}

func NewDefacloptionlistContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DefacloptionlistContext {
	var p = new(DefacloptionlistContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_defacloptionlist

	return p
}

func (s *DefacloptionlistContext) GetParser() antlr.Parser { return s.parser }

func (s *DefacloptionlistContext) AllDefacloption() []IDefacloptionContext {
	children := s.GetChildren()
	len := 0
	for _, ctx := range children {
		if _, ok := ctx.(IDefacloptionContext); ok {
			len++
		}
	}

	tst := make([]IDefacloptionContext, len)
	i := 0
	for _, ctx := range children {
		if t, ok := ctx.(IDefacloptionContext); ok {
			tst[i] = t.(IDefacloptionContext)
			i++
		}
	}

	return tst
}

func (s *DefacloptionlistContext) Defacloption(i int) IDefacloptionContext {
	var t antlr.RuleContext
	j := 0
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IDefacloptionContext); ok {
			if j == i {
				t = ctx.(antlr.RuleContext)
				break
			}
			j++
		}
	}

	if t == nil {
		return nil
	}

	return t.(IDefacloptionContext)
}

func (s *DefacloptionlistContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *DefacloptionlistContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *DefacloptionlistContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterDefacloptionlist(s)
	}
}

func (s *DefacloptionlistContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitDefacloptionlist(s)
	}
}

func (s *DefacloptionlistContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitDefacloptionlist(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Defacloptionlist() (localctx IDefacloptionlistContext) {
	localctx = NewDefacloptionlistContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 580, PostgreSQLParserRULE_defacloptionlist)
	var _la int

	p.EnterOuterAlt(localctx, 1)
	p.SetState(5193)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}
	_la = p.GetTokenStream().LA(1)

	for _la == PostgreSQLParserFOR || _la == PostgreSQLParserIN_P {
		{
			p.SetState(5190)
			p.Defacloption()
		}

		p.SetState(5195)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}
		_la = p.GetTokenStream().LA(1)
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IDefacloptionContext is an interface to support dynamic dispatch.
type IDefacloptionContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	IN_P() antlr.TerminalNode
	SCHEMA() antlr.TerminalNode
	Name_list() IName_listContext
	FOR() antlr.TerminalNode
	ROLE() antlr.TerminalNode
	Role_list() IRole_listContext
	USER() antlr.TerminalNode

	// IsDefacloptionContext differentiates from other interfaces.
	IsDefacloptionContext()
}

type DefacloptionContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyDefacloptionContext() *DefacloptionContext {
	var p = new(DefacloptionContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_defacloption
	return p
}

func InitEmptyDefacloptionContext(p *DefacloptionContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_defacloption
}

func (*DefacloptionContext) IsDefacloptionContext() {}

func NewDefacloptionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DefacloptionContext {
	var p = new(DefacloptionContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_defacloption

	return p
}

func (s *DefacloptionContext) GetParser() antlr.Parser { return s.parser }

func (s *DefacloptionContext) IN_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserIN_P, 0)
}

func (s *DefacloptionContext) SCHEMA() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserSCHEMA, 0)
}

func (s *DefacloptionContext) Name_list() IName_listContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IName_listContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IName_listContext)
}

func (s *DefacloptionContext) FOR() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserFOR, 0)
}

func (s *DefacloptionContext) ROLE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserROLE, 0)
}

func (s *DefacloptionContext) Role_list() IRole_listContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IRole_listContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IRole_listContext)
}

func (s *DefacloptionContext) USER() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserUSER, 0)
}

func (s *DefacloptionContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *DefacloptionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *DefacloptionContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterDefacloption(s)
	}
}

func (s *DefacloptionContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitDefacloption(s)
	}
}

func (s *DefacloptionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitDefacloption(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Defacloption() (localctx IDefacloptionContext) {
	localctx = NewDefacloptionContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 582, PostgreSQLParserRULE_defacloption)
	p.SetState(5205)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 247, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(5196)
			p.Match(PostgreSQLParserIN_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5197)
			p.Match(PostgreSQLParserSCHEMA)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5198)
			p.Name_list()
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(5199)
			p.Match(PostgreSQLParserFOR)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5200)
			p.Match(PostgreSQLParserROLE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5201)
			p.Role_list()
		}

	case 3:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(5202)
			p.Match(PostgreSQLParserFOR)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5203)
			p.Match(PostgreSQLParserUSER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5204)
			p.Role_list()
		}

	case antlr.ATNInvalidAltNumber:
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IDefaclactionContext is an interface to support dynamic dispatch.
type IDefaclactionContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	GRANT() antlr.TerminalNode
	Privileges() IPrivilegesContext
	ON() antlr.TerminalNode
	Defacl_privilege_target() IDefacl_privilege_targetContext
	TO() antlr.TerminalNode
	Grantee_list() IGrantee_listContext
	Opt_grant_grant_option() IOpt_grant_grant_optionContext
	REVOKE() antlr.TerminalNode
	FROM() antlr.TerminalNode
	Opt_drop_behavior() IOpt_drop_behaviorContext
	OPTION() antlr.TerminalNode
	FOR() antlr.TerminalNode

	// IsDefaclactionContext differentiates from other interfaces.
	IsDefaclactionContext()
}

type DefaclactionContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyDefaclactionContext() *DefaclactionContext {
	var p = new(DefaclactionContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_defaclaction
	return p
}

func InitEmptyDefaclactionContext(p *DefaclactionContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_defaclaction
}

func (*DefaclactionContext) IsDefaclactionContext() {}

func NewDefaclactionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DefaclactionContext {
	var p = new(DefaclactionContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_defaclaction

	return p
}

func (s *DefaclactionContext) GetParser() antlr.Parser { return s.parser }

func (s *DefaclactionContext) GRANT() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserGRANT, 0)
}

func (s *DefaclactionContext) Privileges() IPrivilegesContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IPrivilegesContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IPrivilegesContext)
}

func (s *DefaclactionContext) ON() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserON, 0)
}

func (s *DefaclactionContext) Defacl_privilege_target() IDefacl_privilege_targetContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IDefacl_privilege_targetContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IDefacl_privilege_targetContext)
}

func (s *DefaclactionContext) TO() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserTO, 0)
}

func (s *DefaclactionContext) Grantee_list() IGrantee_listContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IGrantee_listContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IGrantee_listContext)
}

func (s *DefaclactionContext) Opt_grant_grant_option() IOpt_grant_grant_optionContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOpt_grant_grant_optionContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOpt_grant_grant_optionContext)
}

func (s *DefaclactionContext) REVOKE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserREVOKE, 0)
}

func (s *DefaclactionContext) FROM() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserFROM, 0)
}

func (s *DefaclactionContext) Opt_drop_behavior() IOpt_drop_behaviorContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOpt_drop_behaviorContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOpt_drop_behaviorContext)
}

func (s *DefaclactionContext) OPTION() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserOPTION, 0)
}

func (s *DefaclactionContext) FOR() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserFOR, 0)
}

func (s *DefaclactionContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *DefaclactionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *DefaclactionContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterDefaclaction(s)
	}
}

func (s *DefaclactionContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitDefaclaction(s)
	}
}

func (s *DefaclactionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitDefaclaction(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Defaclaction() (localctx IDefaclactionContext) {
	localctx = NewDefaclactionContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 584, PostgreSQLParserRULE_defaclaction)
	p.SetState(5234)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 248, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(5207)
			p.Match(PostgreSQLParserGRANT)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5208)
			p.Privileges()
		}
		{
			p.SetState(5209)
			p.Match(PostgreSQLParserON)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5210)
			p.Defacl_privilege_target()
		}
		{
			p.SetState(5211)
			p.Match(PostgreSQLParserTO)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5212)
			p.Grantee_list()
		}
		{
			p.SetState(5213)
			p.Opt_grant_grant_option()
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(5215)
			p.Match(PostgreSQLParserREVOKE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5216)
			p.Privileges()
		}
		{
			p.SetState(5217)
			p.Match(PostgreSQLParserON)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5218)
			p.Defacl_privilege_target()
		}
		{
			p.SetState(5219)
			p.Match(PostgreSQLParserFROM)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5220)
			p.Grantee_list()
		}
		{
			p.SetState(5221)
			p.Opt_drop_behavior()
		}

	case 3:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(5223)
			p.Match(PostgreSQLParserREVOKE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5224)
			p.Match(PostgreSQLParserGRANT)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5225)
			p.Match(PostgreSQLParserOPTION)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5226)
			p.Match(PostgreSQLParserFOR)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5227)
			p.Privileges()
		}
		{
			p.SetState(5228)
			p.Match(PostgreSQLParserON)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5229)
			p.Defacl_privilege_target()
		}
		{
			p.SetState(5230)
			p.Match(PostgreSQLParserFROM)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5231)
			p.Grantee_list()
		}
		{
			p.SetState(5232)
			p.Opt_drop_behavior()
		}

	case antlr.ATNInvalidAltNumber:
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IDefacl_privilege_targetContext is an interface to support dynamic dispatch.
type IDefacl_privilege_targetContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	TABLES() antlr.TerminalNode
	FUNCTIONS() antlr.TerminalNode
	ROUTINES() antlr.TerminalNode
	SEQUENCES() antlr.TerminalNode
	TYPES_P() antlr.TerminalNode
	SCHEMAS() antlr.TerminalNode

	// IsDefacl_privilege_targetContext differentiates from other interfaces.
	IsDefacl_privilege_targetContext()
}

type Defacl_privilege_targetContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyDefacl_privilege_targetContext() *Defacl_privilege_targetContext {
	var p = new(Defacl_privilege_targetContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_defacl_privilege_target
	return p
}

func InitEmptyDefacl_privilege_targetContext(p *Defacl_privilege_targetContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_defacl_privilege_target
}

func (*Defacl_privilege_targetContext) IsDefacl_privilege_targetContext() {}

func NewDefacl_privilege_targetContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Defacl_privilege_targetContext {
	var p = new(Defacl_privilege_targetContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_defacl_privilege_target

	return p
}

func (s *Defacl_privilege_targetContext) GetParser() antlr.Parser { return s.parser }

func (s *Defacl_privilege_targetContext) TABLES() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserTABLES, 0)
}

func (s *Defacl_privilege_targetContext) FUNCTIONS() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserFUNCTIONS, 0)
}

func (s *Defacl_privilege_targetContext) ROUTINES() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserROUTINES, 0)
}

func (s *Defacl_privilege_targetContext) SEQUENCES() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserSEQUENCES, 0)
}

func (s *Defacl_privilege_targetContext) TYPES_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserTYPES_P, 0)
}

func (s *Defacl_privilege_targetContext) SCHEMAS() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserSCHEMAS, 0)
}

func (s *Defacl_privilege_targetContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Defacl_privilege_targetContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Defacl_privilege_targetContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterDefacl_privilege_target(s)
	}
}

func (s *Defacl_privilege_targetContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitDefacl_privilege_target(s)
	}
}

func (s *Defacl_privilege_targetContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitDefacl_privilege_target(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Defacl_privilege_target() (localctx IDefacl_privilege_targetContext) {
	localctx = NewDefacl_privilege_targetContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 586, PostgreSQLParserRULE_defacl_privilege_target)
	var _la int

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(5236)
		_la = p.GetTokenStream().LA(1)

		if !(_la == PostgreSQLParserFUNCTIONS || ((int64((_la-322)) & ^0x3f) == 0 && ((int64(1)<<(_la-322))&4297064449) != 0) || _la == PostgreSQLParserROUTINES || _la == PostgreSQLParserSCHEMAS) {
			p.GetErrorHandler().RecoverInline(p)
		} else {
			p.GetErrorHandler().ReportMatch(p)
			p.Consume()
		}
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IIndexstmtContext is an interface to support dynamic dispatch.
type IIndexstmtContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	CREATE() antlr.TerminalNode
	Opt_unique() IOpt_uniqueContext
	INDEX() antlr.TerminalNode
	Opt_concurrently() IOpt_concurrentlyContext
	Opt_index_name() IOpt_index_nameContext
	ON() antlr.TerminalNode
	Relation_expr() IRelation_exprContext
	Access_method_clause() IAccess_method_clauseContext
	OPEN_PAREN() antlr.TerminalNode
	Index_params() IIndex_paramsContext
	CLOSE_PAREN() antlr.TerminalNode
	Opt_include() IOpt_includeContext
	Opt_reloptions() IOpt_reloptionsContext
	Opttablespace() IOpttablespaceContext
	Where_clause() IWhere_clauseContext
	IF_P() antlr.TerminalNode
	NOT() antlr.TerminalNode
	EXISTS() antlr.TerminalNode
	Name() INameContext

	// IsIndexstmtContext differentiates from other interfaces.
	IsIndexstmtContext()
}

type IndexstmtContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyIndexstmtContext() *IndexstmtContext {
	var p = new(IndexstmtContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_indexstmt
	return p
}

func InitEmptyIndexstmtContext(p *IndexstmtContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_indexstmt
}

func (*IndexstmtContext) IsIndexstmtContext() {}

func NewIndexstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *IndexstmtContext {
	var p = new(IndexstmtContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_indexstmt

	return p
}

func (s *IndexstmtContext) GetParser() antlr.Parser { return s.parser }

func (s *IndexstmtContext) CREATE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCREATE, 0)
}

func (s *IndexstmtContext) Opt_unique() IOpt_uniqueContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOpt_uniqueContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOpt_uniqueContext)
}

func (s *IndexstmtContext) INDEX() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserINDEX, 0)
}

func (s *IndexstmtContext) Opt_concurrently() IOpt_concurrentlyContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOpt_concurrentlyContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOpt_concurrentlyContext)
}

func (s *IndexstmtContext) Opt_index_name() IOpt_index_nameContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOpt_index_nameContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOpt_index_nameContext)
}

func (s *IndexstmtContext) ON() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserON, 0)
}

func (s *IndexstmtContext) Relation_expr() IRelation_exprContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IRelation_exprContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IRelation_exprContext)
}

func (s *IndexstmtContext) Access_method_clause() IAccess_method_clauseContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IAccess_method_clauseContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IAccess_method_clauseContext)
}

func (s *IndexstmtContext) OPEN_PAREN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserOPEN_PAREN, 0)
}

func (s *IndexstmtContext) Index_params() IIndex_paramsContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IIndex_paramsContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IIndex_paramsContext)
}

func (s *IndexstmtContext) CLOSE_PAREN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCLOSE_PAREN, 0)
}

func (s *IndexstmtContext) Opt_include() IOpt_includeContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOpt_includeContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOpt_includeContext)
}

func (s *IndexstmtContext) Opt_reloptions() IOpt_reloptionsContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOpt_reloptionsContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOpt_reloptionsContext)
}

func (s *IndexstmtContext) Opttablespace() IOpttablespaceContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOpttablespaceContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOpttablespaceContext)
}

func (s *IndexstmtContext) Where_clause() IWhere_clauseContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IWhere_clauseContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IWhere_clauseContext)
}

func (s *IndexstmtContext) IF_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserIF_P, 0)
}

func (s *IndexstmtContext) NOT() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserNOT, 0)
}

func (s *IndexstmtContext) EXISTS() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserEXISTS, 0)
}

func (s *IndexstmtContext) Name() INameContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(INameContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(INameContext)
}

func (s *IndexstmtContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *IndexstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *IndexstmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterIndexstmt(s)
	}
}

func (s *IndexstmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitIndexstmt(s)
	}
}

func (s *IndexstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitIndexstmt(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Indexstmt() (localctx IIndexstmtContext) {
	localctx = NewIndexstmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 588, PostgreSQLParserRULE_indexstmt)
	p.SetState(5273)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 249, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(5238)
			p.Match(PostgreSQLParserCREATE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5239)
			p.Opt_unique()
		}
		{
			p.SetState(5240)
			p.Match(PostgreSQLParserINDEX)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5241)
			p.Opt_concurrently()
		}
		{
			p.SetState(5242)
			p.Opt_index_name()
		}
		{
			p.SetState(5243)
			p.Match(PostgreSQLParserON)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5244)
			p.Relation_expr()
		}
		{
			p.SetState(5245)
			p.Access_method_clause()
		}
		{
			p.SetState(5246)
			p.Match(PostgreSQLParserOPEN_PAREN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5247)
			p.Index_params()
		}
		{
			p.SetState(5248)
			p.Match(PostgreSQLParserCLOSE_PAREN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5249)
			p.Opt_include()
		}
		{
			p.SetState(5250)
			p.Opt_reloptions()
		}
		{
			p.SetState(5251)
			p.Opttablespace()
		}
		{
			p.SetState(5252)
			p.Where_clause()
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(5254)
			p.Match(PostgreSQLParserCREATE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5255)
			p.Opt_unique()
		}
		{
			p.SetState(5256)
			p.Match(PostgreSQLParserINDEX)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5257)
			p.Opt_concurrently()
		}
		{
			p.SetState(5258)
			p.Match(PostgreSQLParserIF_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5259)
			p.Match(PostgreSQLParserNOT)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5260)
			p.Match(PostgreSQLParserEXISTS)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5261)
			p.Name()
		}
		{
			p.SetState(5262)
			p.Match(PostgreSQLParserON)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5263)
			p.Relation_expr()
		}
		{
			p.SetState(5264)
			p.Access_method_clause()
		}
		{
			p.SetState(5265)
			p.Match(PostgreSQLParserOPEN_PAREN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5266)
			p.Index_params()
		}
		{
			p.SetState(5267)
			p.Match(PostgreSQLParserCLOSE_PAREN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5268)
			p.Opt_include()
		}
		{
			p.SetState(5269)
			p.Opt_reloptions()
		}
		{
			p.SetState(5270)
			p.Opttablespace()
		}
		{
			p.SetState(5271)
			p.Where_clause()
		}

	case antlr.ATNInvalidAltNumber:
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IOpt_uniqueContext is an interface to support dynamic dispatch.
type IOpt_uniqueContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	UNIQUE() antlr.TerminalNode

	// IsOpt_uniqueContext differentiates from other interfaces.
	IsOpt_uniqueContext()
}

type Opt_uniqueContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyOpt_uniqueContext() *Opt_uniqueContext {
	var p = new(Opt_uniqueContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opt_unique
	return p
}

func InitEmptyOpt_uniqueContext(p *Opt_uniqueContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opt_unique
}

func (*Opt_uniqueContext) IsOpt_uniqueContext() {}

func NewOpt_uniqueContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_uniqueContext {
	var p = new(Opt_uniqueContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_opt_unique

	return p
}

func (s *Opt_uniqueContext) GetParser() antlr.Parser { return s.parser }

func (s *Opt_uniqueContext) UNIQUE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserUNIQUE, 0)
}

func (s *Opt_uniqueContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Opt_uniqueContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Opt_uniqueContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterOpt_unique(s)
	}
}

func (s *Opt_uniqueContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitOpt_unique(s)
	}
}

func (s *Opt_uniqueContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitOpt_unique(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Opt_unique() (localctx IOpt_uniqueContext) {
	localctx = NewOpt_uniqueContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 590, PostgreSQLParserRULE_opt_unique)
	p.SetState(5277)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetTokenStream().LA(1) {
	case PostgreSQLParserUNIQUE:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(5275)
			p.Match(PostgreSQLParserUNIQUE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case PostgreSQLParserINDEX:
		p.EnterOuterAlt(localctx, 2)

	default:
		p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IOpt_concurrentlyContext is an interface to support dynamic dispatch.
type IOpt_concurrentlyContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	CONCURRENTLY() antlr.TerminalNode

	// IsOpt_concurrentlyContext differentiates from other interfaces.
	IsOpt_concurrentlyContext()
}

type Opt_concurrentlyContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyOpt_concurrentlyContext() *Opt_concurrentlyContext {
	var p = new(Opt_concurrentlyContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opt_concurrently
	return p
}

func InitEmptyOpt_concurrentlyContext(p *Opt_concurrentlyContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opt_concurrently
}

func (*Opt_concurrentlyContext) IsOpt_concurrentlyContext() {}

func NewOpt_concurrentlyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_concurrentlyContext {
	var p = new(Opt_concurrentlyContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_opt_concurrently

	return p
}

func (s *Opt_concurrentlyContext) GetParser() antlr.Parser { return s.parser }

func (s *Opt_concurrentlyContext) CONCURRENTLY() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCONCURRENTLY, 0)
}

func (s *Opt_concurrentlyContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Opt_concurrentlyContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Opt_concurrentlyContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterOpt_concurrently(s)
	}
}

func (s *Opt_concurrentlyContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitOpt_concurrently(s)
	}
}

func (s *Opt_concurrentlyContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitOpt_concurrently(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Opt_concurrently() (localctx IOpt_concurrentlyContext) {
	localctx = NewOpt_concurrentlyContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 592, PostgreSQLParserRULE_opt_concurrently)
	p.SetState(5281)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetTokenStream().LA(1) {
	case PostgreSQLParserCONCURRENTLY:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(5279)
			p.Match(PostgreSQLParserCONCURRENTLY)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case PostgreSQLParserAND, PostgreSQLParserARRAY, PostgreSQLParserCOLLATE, PostgreSQLParserCOLUMN, PostgreSQLParserCONSTRAINT, PostgreSQLParserDEFAULT, PostgreSQLParserDO, PostgreSQLParserFETCH, PostgreSQLParserON, PostgreSQLParserTABLE, PostgreSQLParserIS, PostgreSQLParserLEFT, PostgreSQLParserOUTER_P, PostgreSQLParserOVER, PostgreSQLParserRIGHT, PostgreSQLParserABORT_P, PostgreSQLParserABSOLUTE_P, PostgreSQLParserACCESS, PostgreSQLParserACTION, PostgreSQLParserADD_P, PostgreSQLParserADMIN, PostgreSQLParserAFTER, PostgreSQLParserAGGREGATE, PostgreSQLParserALSO, PostgreSQLParserALTER, PostgreSQLParserALWAYS, PostgreSQLParserASSERTION, PostgreSQLParserASSIGNMENT, PostgreSQLParserAT, PostgreSQLParserATTRIBUTE, PostgreSQLParserBACKWARD, PostgreSQLParserBEFORE, PostgreSQLParserBEGIN_P, PostgreSQLParserBY, PostgreSQLParserCACHE, PostgreSQLParserCALLED, PostgreSQLParserCASCADE, PostgreSQLParserCASCADED, PostgreSQLParserCATALOG, PostgreSQLParserCHAIN, PostgreSQLParserCHARACTERISTICS, PostgreSQLParserCHECKPOINT, PostgreSQLParserCLASS, PostgreSQLParserCLOSE, PostgreSQLParserCLUSTER, PostgreSQLParserCOMMENT, PostgreSQLParserCOMMENTS, PostgreSQLParserCOMMIT, PostgreSQLParserCOMMITTED, PostgreSQLParserCONFIGURATION, PostgreSQLParserCONNECTION, PostgreSQLParserCONSTRAINTS, PostgreSQLParserCONTENT_P, PostgreSQLParserCONTINUE_P, PostgreSQLParserCONVERSION_P, PostgreSQLParserCOPY, PostgreSQLParserCOST, PostgreSQLParserCSV, PostgreSQLParserCURSOR, PostgreSQLParserCYCLE, PostgreSQLParserDATA_P, PostgreSQLParserDATABASE, PostgreSQLParserDAY_P, PostgreSQLParserDEALLOCATE, PostgreSQLParserDECLARE, PostgreSQLParserDEFAULTS, PostgreSQLParserDEFERRED, PostgreSQLParserDEFINER, PostgreSQLParserDELETE_P, PostgreSQLParserDELIMITER, PostgreSQLParserDELIMITERS, PostgreSQLParserDICTIONARY, PostgreSQLParserDISABLE_P, PostgreSQLParserDISCARD, PostgreSQLParserDOCUMENT_P, PostgreSQLParserDOMAIN_P, PostgreSQLParserDOUBLE_P, PostgreSQLParserDROP, PostgreSQLParserEACH, PostgreSQLParserENABLE_P, PostgreSQLParserENCODING, PostgreSQLParserENCRYPTED, PostgreSQLParserENUM_P, PostgreSQLParserESCAPE, PostgreSQLParserEVENT, PostgreSQLParserEXCLUDE, PostgreSQLParserEXCLUDING, PostgreSQLParserEXCLUSIVE, PostgreSQLParserEXECUTE, PostgreSQLParserEXPLAIN, PostgreSQLParserEXTENSION, PostgreSQLParserEXTERNAL, PostgreSQLParserFAMILY, PostgreSQLParserFIRST_P, PostgreSQLParserFOLLOWING, PostgreSQLParserFORCE, PostgreSQLParserFORWARD, PostgreSQLParserFUNCTION, PostgreSQLParserFUNCTIONS, PostgreSQLParserGLOBAL, PostgreSQLParserGRANTED, PostgreSQLParserHANDLER, PostgreSQLParserHEADER_P, PostgreSQLParserHOLD, PostgreSQLParserHOUR_P, PostgreSQLParserIDENTITY_P, PostgreSQLParserIF_P, PostgreSQLParserIMMEDIATE, PostgreSQLParserIMMUTABLE, PostgreSQLParserIMPLICIT_P, PostgreSQLParserINCLUDING, PostgreSQLParserINCREMENT, PostgreSQLParserINDEX, PostgreSQLParserINDEXES, PostgreSQLParserINHERIT, PostgreSQLParserINHERITS, PostgreSQLParserINLINE_P, PostgreSQLParserINSENSITIVE, PostgreSQLParserINSERT, PostgreSQLParserINSTEAD, PostgreSQLParserINVOKER, PostgreSQLParserISOLATION, PostgreSQLParserKEY, PostgreSQLParserLABEL, PostgreSQLParserLANGUAGE, PostgreSQLParserLARGE_P, PostgreSQLParserLAST_P, PostgreSQLParserLEAKPROOF, PostgreSQLParserLEVEL, PostgreSQLParserLISTEN, PostgreSQLParserLOAD, PostgreSQLParserLOCAL, PostgreSQLParserLOCATION, PostgreSQLParserLOCK_P, PostgreSQLParserMAPPING, PostgreSQLParserMATCH, PostgreSQLParserMATERIALIZED, PostgreSQLParserMAXVALUE, PostgreSQLParserMINUTE_P, PostgreSQLParserMINVALUE, PostgreSQLParserMODE, PostgreSQLParserMONTH_P, PostgreSQLParserMOVE, PostgreSQLParserNAME_P, PostgreSQLParserNAMES, PostgreSQLParserNEXT, PostgreSQLParserNO, PostgreSQLParserNOTHING, PostgreSQLParserNOTIFY, PostgreSQLParserNOWAIT, PostgreSQLParserNULLS_P, PostgreSQLParserOBJECT_P, PostgreSQLParserOF, PostgreSQLParserOFF, PostgreSQLParserOIDS, PostgreSQLParserOPERATOR, PostgreSQLParserOPTION, PostgreSQLParserOPTIONS, PostgreSQLParserOWNED, PostgreSQLParserOWNER, PostgreSQLParserPARSER, PostgreSQLParserPARTIAL, PostgreSQLParserPARTITION, PostgreSQLParserPASSING, PostgreSQLParserPASSWORD, PostgreSQLParserPLANS, PostgreSQLParserPRECEDING, PostgreSQLParserPREPARE, PostgreSQLParserPREPARED, PostgreSQLParserPRESERVE, PostgreSQLParserPRIOR, PostgreSQLParserPRIVILEGES, PostgreSQLParserPROCEDURAL, PostgreSQLParserPROCEDURE, PostgreSQLParserPROGRAM, PostgreSQLParserQUOTE, PostgreSQLParserRANGE, PostgreSQLParserREAD, PostgreSQLParserREASSIGN, PostgreSQLParserRECHECK, PostgreSQLParserRECURSIVE, PostgreSQLParserREF, PostgreSQLParserREFRESH, PostgreSQLParserREINDEX, PostgreSQLParserRELATIVE_P, PostgreSQLParserRELEASE, PostgreSQLParserRENAME, PostgreSQLParserREPEATABLE, PostgreSQLParserREPLACE, PostgreSQLParserREPLICA, PostgreSQLParserRESET, PostgreSQLParserRESTART, PostgreSQLParserRESTRICT, PostgreSQLParserRETURNS, PostgreSQLParserREVOKE, PostgreSQLParserROLE, PostgreSQLParserROLLBACK, PostgreSQLParserROWS, PostgreSQLParserRULE, PostgreSQLParserSAVEPOINT, PostgreSQLParserSCHEMA, PostgreSQLParserSCROLL, PostgreSQLParserSEARCH, PostgreSQLParserSECOND_P, PostgreSQLParserSECURITY, PostgreSQLParserSEQUENCE, PostgreSQLParserSEQUENCES, PostgreSQLParserSERIALIZABLE, PostgreSQLParserSERVER, PostgreSQLParserSESSION, PostgreSQLParserSET, PostgreSQLParserSHARE, PostgreSQLParserSHOW, PostgreSQLParserSIMPLE, PostgreSQLParserSNAPSHOT, PostgreSQLParserSTABLE, PostgreSQLParserSTANDALONE_P, PostgreSQLParserSTART, PostgreSQLParserSTATEMENT, PostgreSQLParserSTATISTICS, PostgreSQLParserSTDIN, PostgreSQLParserSTDOUT, PostgreSQLParserSTORAGE, PostgreSQLParserSTRICT_P, PostgreSQLParserSTRIP_P, PostgreSQLParserSYSID, PostgreSQLParserSYSTEM_P, PostgreSQLParserTABLES, PostgreSQLParserTABLESPACE, PostgreSQLParserTEMP, PostgreSQLParserTEMPLATE, PostgreSQLParserTEMPORARY, PostgreSQLParserTEXT_P, PostgreSQLParserTRANSACTION, PostgreSQLParserTRIGGER, PostgreSQLParserTRUNCATE, PostgreSQLParserTRUSTED, PostgreSQLParserTYPE_P, PostgreSQLParserTYPES_P, PostgreSQLParserUNBOUNDED, PostgreSQLParserUNCOMMITTED, PostgreSQLParserUNENCRYPTED, PostgreSQLParserUNKNOWN, PostgreSQLParserUNLISTEN, PostgreSQLParserUNLOGGED, PostgreSQLParserUNTIL, PostgreSQLParserUPDATE, PostgreSQLParserVACUUM, PostgreSQLParserVALID, PostgreSQLParserVALIDATE, PostgreSQLParserVALIDATOR, PostgreSQLParserVARYING, PostgreSQLParserVERSION_P, PostgreSQLParserVIEW, PostgreSQLParserVOLATILE, PostgreSQLParserWHITESPACE_P, PostgreSQLParserWITHOUT, PostgreSQLParserWORK, PostgreSQLParserWRAPPER, PostgreSQLParserWRITE, PostgreSQLParserXML_P, PostgreSQLParserYEAR_P, PostgreSQLParserYES_P, PostgreSQLParserZONE, PostgreSQLParserBETWEEN, PostgreSQLParserBIGINT, PostgreSQLParserBIT, PostgreSQLParserBOOLEAN_P, PostgreSQLParserCHAR_P, PostgreSQLParserCHARACTER, PostgreSQLParserCOALESCE, PostgreSQLParserDEC, PostgreSQLParserDECIMAL_P, PostgreSQLParserEXISTS, PostgreSQLParserEXTRACT, PostgreSQLParserFLOAT_P, PostgreSQLParserGREATEST, PostgreSQLParserINOUT, PostgreSQLParserINT_P, PostgreSQLParserINTEGER, PostgreSQLParserINTERVAL, PostgreSQLParserLEAST, PostgreSQLParserNATIONAL, PostgreSQLParserNCHAR, PostgreSQLParserNONE, PostgreSQLParserNULLIF, PostgreSQLParserNUMERIC, PostgreSQLParserOVERLAY, PostgreSQLParserPOSITION, PostgreSQLParserPRECISION, PostgreSQLParserREAL, PostgreSQLParserROW, PostgreSQLParserSETOF, PostgreSQLParserSMALLINT, PostgreSQLParserSUBSTRING, PostgreSQLParserTIME, PostgreSQLParserTIMESTAMP, PostgreSQLParserTREAT, PostgreSQLParserTRIM, PostgreSQLParserVALUES, PostgreSQLParserVARCHAR, PostgreSQLParserXMLATTRIBUTES, PostgreSQLParserXMLCOMMENT, PostgreSQLParserXMLAGG, PostgreSQLParserXML_IS_WELL_FORMED, PostgreSQLParserXML_IS_WELL_FORMED_DOCUMENT, PostgreSQLParserXML_IS_WELL_FORMED_CONTENT, PostgreSQLParserXPATH, PostgreSQLParserXPATH_EXISTS, PostgreSQLParserXMLCONCAT, PostgreSQLParserXMLELEMENT, PostgreSQLParserXMLEXISTS, PostgreSQLParserXMLFOREST, PostgreSQLParserXMLPARSE, PostgreSQLParserXMLPI, PostgreSQLParserXMLROOT, PostgreSQLParserXMLSERIALIZE, PostgreSQLParserCALL, PostgreSQLParserCURRENT_P, PostgreSQLParserATTACH, PostgreSQLParserDETACH, PostgreSQLParserEXPRESSION, PostgreSQLParserGENERATED, PostgreSQLParserLOGGED, PostgreSQLParserSTORED, PostgreSQLParserINCLUDE, PostgreSQLParserROUTINE, PostgreSQLParserTRANSFORM, PostgreSQLParserIMPORT_P, PostgreSQLParserPOLICY, PostgreSQLParserMETHOD, PostgreSQLParserREFERENCING, PostgreSQLParserNEW, PostgreSQLParserOLD, PostgreSQLParserVALUE_P, PostgreSQLParserSUBSCRIPTION, PostgreSQLParserPUBLICATION, PostgreSQLParserOUT_P, PostgreSQLParserROUTINES, PostgreSQLParserSCHEMAS, PostgreSQLParserPROCEDURES, PostgreSQLParserINPUT_P, PostgreSQLParserSUPPORT, PostgreSQLParserPARALLEL, PostgreSQLParserSQL_P, PostgreSQLParserDEPENDS, PostgreSQLParserOVERRIDING, PostgreSQLParserCONFLICT, PostgreSQLParserSKIP_P, PostgreSQLParserLOCKED, PostgreSQLParserTIES, PostgreSQLParserROLLUP, PostgreSQLParserCUBE, PostgreSQLParserGROUPING, PostgreSQLParserSETS, PostgreSQLParserORDINALITY, PostgreSQLParserXMLTABLE, PostgreSQLParserCOLUMNS, PostgreSQLParserXMLNAMESPACES, PostgreSQLParserROWTYPE, PostgreSQLParserNORMALIZED, PostgreSQLParserWITHIN, PostgreSQLParserFILTER, PostgreSQLParserGROUPS, PostgreSQLParserOTHERS, PostgreSQLParserNFC, PostgreSQLParserNFD, PostgreSQLParserNFKC, PostgreSQLParserNFKD, PostgreSQLParserUESCAPE, PostgreSQLParserVIEWS, PostgreSQLParserNORMALIZE, PostgreSQLParserDUMP, PostgreSQLParserPRINT_STRICT_PARAMS, PostgreSQLParserVARIABLE_CONFLICT, PostgreSQLParserERROR, PostgreSQLParserUSE_VARIABLE, PostgreSQLParserUSE_COLUMN, PostgreSQLParserALIAS, PostgreSQLParserCONSTANT, PostgreSQLParserPERFORM, PostgreSQLParserGET, PostgreSQLParserDIAGNOSTICS, PostgreSQLParserSTACKED, PostgreSQLParserELSIF, PostgreSQLParserREVERSE, PostgreSQLParserSLICE, PostgreSQLParserEXIT, PostgreSQLParserRETURN, PostgreSQLParserQUERY, PostgreSQLParserRAISE, PostgreSQLParserSQLSTATE, PostgreSQLParserDEBUG, PostgreSQLParserLOG, PostgreSQLParserINFO, PostgreSQLParserNOTICE, PostgreSQLParserWARNING, PostgreSQLParserEXCEPTION, PostgreSQLParserASSERT, PostgreSQLParserOPEN, PostgreSQLParserABS, PostgreSQLParserCBRT, PostgreSQLParserCEIL, PostgreSQLParserCEILING, PostgreSQLParserDEGREES, PostgreSQLParserDIV, PostgreSQLParserEXP, PostgreSQLParserFACTORIAL, PostgreSQLParserFLOOR, PostgreSQLParserGCD, PostgreSQLParserLCM, PostgreSQLParserLN, PostgreSQLParserLOG10, PostgreSQLParserMIN_SCALE, PostgreSQLParserMOD, PostgreSQLParserPI, PostgreSQLParserPOWER, PostgreSQLParserRADIANS, PostgreSQLParserROUND, PostgreSQLParserSCALE, PostgreSQLParserSIGN, PostgreSQLParserSQRT, PostgreSQLParserTRIM_SCALE, PostgreSQLParserTRUNC, PostgreSQLParserWIDTH_BUCKET, PostgreSQLParserRANDOM, PostgreSQLParserSETSEED, PostgreSQLParserACOS, PostgreSQLParserACOSD, PostgreSQLParserASIN, PostgreSQLParserASIND, PostgreSQLParserATAN, PostgreSQLParserATAND, PostgreSQLParserATAN2, PostgreSQLParserATAN2D, PostgreSQLParserCOS, PostgreSQLParserCOSD, PostgreSQLParserCOT, PostgreSQLParserCOTD, PostgreSQLParserSIN, PostgreSQLParserSIND, PostgreSQLParserTAN, PostgreSQLParserTAND, PostgreSQLParserSINH, PostgreSQLParserCOSH, PostgreSQLParserTANH, PostgreSQLParserASINH, PostgreSQLParserACOSH, PostgreSQLParserATANH, PostgreSQLParserBIT_LENGTH, PostgreSQLParserCHAR_LENGTH, PostgreSQLParserCHARACTER_LENGTH, PostgreSQLParserLOWER, PostgreSQLParserOCTET_LENGTH, PostgreSQLParserUPPER, PostgreSQLParserASCII, PostgreSQLParserBTRIM, PostgreSQLParserCHR, PostgreSQLParserCONCAT, PostgreSQLParserCONCAT_WS, PostgreSQLParserFORMAT, PostgreSQLParserINITCAP, PostgreSQLParserLENGTH, PostgreSQLParserLPAD, PostgreSQLParserLTRIM, PostgreSQLParserMD5, PostgreSQLParserPARSE_IDENT, PostgreSQLParserPG_CLIENT_ENCODING, PostgreSQLParserQUOTE_IDENT, PostgreSQLParserQUOTE_LITERAL, PostgreSQLParserQUOTE_NULLABLE, PostgreSQLParserREGEXP_COUNT, PostgreSQLParserREGEXP_INSTR, PostgreSQLParserREGEXP_LIKE, PostgreSQLParserREGEXP_MATCH, PostgreSQLParserREGEXP_MATCHES, PostgreSQLParserREGEXP_REPLACE, PostgreSQLParserREGEXP_SPLIT_TO_ARRAY, PostgreSQLParserREGEXP_SPLIT_TO_TABLE, PostgreSQLParserREGEXP_SUBSTR, PostgreSQLParserREPEAT, PostgreSQLParserRPAD, PostgreSQLParserRTRIM, PostgreSQLParserSPLIT_PART, PostgreSQLParserSTARTS_WITH, PostgreSQLParserSTRING_TO_ARRAY, PostgreSQLParserSTRING_TO_TABLE, PostgreSQLParserSTRPOS, PostgreSQLParserSUBSTR, PostgreSQLParserTO_ASCII, PostgreSQLParserTO_HEX, PostgreSQLParserTRANSLATE, PostgreSQLParserUNISTR, PostgreSQLParserAGE, PostgreSQLParserCLOCK_TIMESTAMP, PostgreSQLParserDATE_BIN, PostgreSQLParserDATE_PART, PostgreSQLParserDATE_TRUNC, PostgreSQLParserISFINITE, PostgreSQLParserJUSTIFY_DAYS, PostgreSQLParserJUSTIFY_HOURS, PostgreSQLParserJUSTIFY_INTERVAL, PostgreSQLParserMAKE_DATE, PostgreSQLParserMAKE_INTERVAL, PostgreSQLParserMAKE_TIME, PostgreSQLParserMAKE_TIMESTAMP, PostgreSQLParserMAKE_TIMESTAMPTZ, PostgreSQLParserNOW, PostgreSQLParserSTATEMENT_TIMESTAMP, PostgreSQLParserTIMEOFDAY, PostgreSQLParserTRANSACTION_TIMESTAMP, PostgreSQLParserTO_TIMESTAMP, PostgreSQLParserTO_CHAR, PostgreSQLParserTO_DATE, PostgreSQLParserTO_NUMBER, PostgreSQLParserIdentifier, PostgreSQLParserQuotedIdentifier, PostgreSQLParserUnicodeQuotedIdentifier, PostgreSQLParserPLSQLVARIABLENAME, PostgreSQLParserPLSQLIDENTIFIER:
		p.EnterOuterAlt(localctx, 2)

	default:
		p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IOpt_index_nameContext is an interface to support dynamic dispatch.
type IOpt_index_nameContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Name() INameContext

	// IsOpt_index_nameContext differentiates from other interfaces.
	IsOpt_index_nameContext()
}

type Opt_index_nameContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyOpt_index_nameContext() *Opt_index_nameContext {
	var p = new(Opt_index_nameContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opt_index_name
	return p
}

func InitEmptyOpt_index_nameContext(p *Opt_index_nameContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opt_index_name
}

func (*Opt_index_nameContext) IsOpt_index_nameContext() {}

func NewOpt_index_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_index_nameContext {
	var p = new(Opt_index_nameContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_opt_index_name

	return p
}

func (s *Opt_index_nameContext) GetParser() antlr.Parser { return s.parser }

func (s *Opt_index_nameContext) Name() INameContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(INameContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(INameContext)
}

func (s *Opt_index_nameContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Opt_index_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Opt_index_nameContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterOpt_index_name(s)
	}
}

func (s *Opt_index_nameContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitOpt_index_name(s)
	}
}

func (s *Opt_index_nameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitOpt_index_name(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Opt_index_name() (localctx IOpt_index_nameContext) {
	localctx = NewOpt_index_nameContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 594, PostgreSQLParserRULE_opt_index_name)
	p.SetState(5285)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetTokenStream().LA(1) {
	case PostgreSQLParserAND, PostgreSQLParserARRAY, PostgreSQLParserCOLLATE, PostgreSQLParserCOLUMN, PostgreSQLParserCONSTRAINT, PostgreSQLParserDEFAULT, PostgreSQLParserDO, PostgreSQLParserFETCH, PostgreSQLParserTABLE, PostgreSQLParserIS, PostgreSQLParserLEFT, PostgreSQLParserOUTER_P, PostgreSQLParserOVER, PostgreSQLParserRIGHT, PostgreSQLParserABORT_P, PostgreSQLParserABSOLUTE_P, PostgreSQLParserACCESS, PostgreSQLParserACTION, PostgreSQLParserADD_P, PostgreSQLParserADMIN, PostgreSQLParserAFTER, PostgreSQLParserAGGREGATE, PostgreSQLParserALSO, PostgreSQLParserALTER, PostgreSQLParserALWAYS, PostgreSQLParserASSERTION, PostgreSQLParserASSIGNMENT, PostgreSQLParserAT, PostgreSQLParserATTRIBUTE, PostgreSQLParserBACKWARD, PostgreSQLParserBEFORE, PostgreSQLParserBEGIN_P, PostgreSQLParserBY, PostgreSQLParserCACHE, PostgreSQLParserCALLED, PostgreSQLParserCASCADE, PostgreSQLParserCASCADED, PostgreSQLParserCATALOG, PostgreSQLParserCHAIN, PostgreSQLParserCHARACTERISTICS, PostgreSQLParserCHECKPOINT, PostgreSQLParserCLASS, PostgreSQLParserCLOSE, PostgreSQLParserCLUSTER, PostgreSQLParserCOMMENT, PostgreSQLParserCOMMENTS, PostgreSQLParserCOMMIT, PostgreSQLParserCOMMITTED, PostgreSQLParserCONFIGURATION, PostgreSQLParserCONNECTION, PostgreSQLParserCONSTRAINTS, PostgreSQLParserCONTENT_P, PostgreSQLParserCONTINUE_P, PostgreSQLParserCONVERSION_P, PostgreSQLParserCOPY, PostgreSQLParserCOST, PostgreSQLParserCSV, PostgreSQLParserCURSOR, PostgreSQLParserCYCLE, PostgreSQLParserDATA_P, PostgreSQLParserDATABASE, PostgreSQLParserDAY_P, PostgreSQLParserDEALLOCATE, PostgreSQLParserDECLARE, PostgreSQLParserDEFAULTS, PostgreSQLParserDEFERRED, PostgreSQLParserDEFINER, PostgreSQLParserDELETE_P, PostgreSQLParserDELIMITER, PostgreSQLParserDELIMITERS, PostgreSQLParserDICTIONARY, PostgreSQLParserDISABLE_P, PostgreSQLParserDISCARD, PostgreSQLParserDOCUMENT_P, PostgreSQLParserDOMAIN_P, PostgreSQLParserDOUBLE_P, PostgreSQLParserDROP, PostgreSQLParserEACH, PostgreSQLParserENABLE_P, PostgreSQLParserENCODING, PostgreSQLParserENCRYPTED, PostgreSQLParserENUM_P, PostgreSQLParserESCAPE, PostgreSQLParserEVENT, PostgreSQLParserEXCLUDE, PostgreSQLParserEXCLUDING, PostgreSQLParserEXCLUSIVE, PostgreSQLParserEXECUTE, PostgreSQLParserEXPLAIN, PostgreSQLParserEXTENSION, PostgreSQLParserEXTERNAL, PostgreSQLParserFAMILY, PostgreSQLParserFIRST_P, PostgreSQLParserFOLLOWING, PostgreSQLParserFORCE, PostgreSQLParserFORWARD, PostgreSQLParserFUNCTION, PostgreSQLParserFUNCTIONS, PostgreSQLParserGLOBAL, PostgreSQLParserGRANTED, PostgreSQLParserHANDLER, PostgreSQLParserHEADER_P, PostgreSQLParserHOLD, PostgreSQLParserHOUR_P, PostgreSQLParserIDENTITY_P, PostgreSQLParserIF_P, PostgreSQLParserIMMEDIATE, PostgreSQLParserIMMUTABLE, PostgreSQLParserIMPLICIT_P, PostgreSQLParserINCLUDING, PostgreSQLParserINCREMENT, PostgreSQLParserINDEX, PostgreSQLParserINDEXES, PostgreSQLParserINHERIT, PostgreSQLParserINHERITS, PostgreSQLParserINLINE_P, PostgreSQLParserINSENSITIVE, PostgreSQLParserINSERT, PostgreSQLParserINSTEAD, PostgreSQLParserINVOKER, PostgreSQLParserISOLATION, PostgreSQLParserKEY, PostgreSQLParserLABEL, PostgreSQLParserLANGUAGE, PostgreSQLParserLARGE_P, PostgreSQLParserLAST_P, PostgreSQLParserLEAKPROOF, PostgreSQLParserLEVEL, PostgreSQLParserLISTEN, PostgreSQLParserLOAD, PostgreSQLParserLOCAL, PostgreSQLParserLOCATION, PostgreSQLParserLOCK_P, PostgreSQLParserMAPPING, PostgreSQLParserMATCH, PostgreSQLParserMATERIALIZED, PostgreSQLParserMAXVALUE, PostgreSQLParserMINUTE_P, PostgreSQLParserMINVALUE, PostgreSQLParserMODE, PostgreSQLParserMONTH_P, PostgreSQLParserMOVE, PostgreSQLParserNAME_P, PostgreSQLParserNAMES, PostgreSQLParserNEXT, PostgreSQLParserNO, PostgreSQLParserNOTHING, PostgreSQLParserNOTIFY, PostgreSQLParserNOWAIT, PostgreSQLParserNULLS_P, PostgreSQLParserOBJECT_P, PostgreSQLParserOF, PostgreSQLParserOFF, PostgreSQLParserOIDS, PostgreSQLParserOPERATOR, PostgreSQLParserOPTION, PostgreSQLParserOPTIONS, PostgreSQLParserOWNED, PostgreSQLParserOWNER, PostgreSQLParserPARSER, PostgreSQLParserPARTIAL, PostgreSQLParserPARTITION, PostgreSQLParserPASSING, PostgreSQLParserPASSWORD, PostgreSQLParserPLANS, PostgreSQLParserPRECEDING, PostgreSQLParserPREPARE, PostgreSQLParserPREPARED, PostgreSQLParserPRESERVE, PostgreSQLParserPRIOR, PostgreSQLParserPRIVILEGES, PostgreSQLParserPROCEDURAL, PostgreSQLParserPROCEDURE, PostgreSQLParserPROGRAM, PostgreSQLParserQUOTE, PostgreSQLParserRANGE, PostgreSQLParserREAD, PostgreSQLParserREASSIGN, PostgreSQLParserRECHECK, PostgreSQLParserRECURSIVE, PostgreSQLParserREF, PostgreSQLParserREFRESH, PostgreSQLParserREINDEX, PostgreSQLParserRELATIVE_P, PostgreSQLParserRELEASE, PostgreSQLParserRENAME, PostgreSQLParserREPEATABLE, PostgreSQLParserREPLACE, PostgreSQLParserREPLICA, PostgreSQLParserRESET, PostgreSQLParserRESTART, PostgreSQLParserRESTRICT, PostgreSQLParserRETURNS, PostgreSQLParserREVOKE, PostgreSQLParserROLE, PostgreSQLParserROLLBACK, PostgreSQLParserROWS, PostgreSQLParserRULE, PostgreSQLParserSAVEPOINT, PostgreSQLParserSCHEMA, PostgreSQLParserSCROLL, PostgreSQLParserSEARCH, PostgreSQLParserSECOND_P, PostgreSQLParserSECURITY, PostgreSQLParserSEQUENCE, PostgreSQLParserSEQUENCES, PostgreSQLParserSERIALIZABLE, PostgreSQLParserSERVER, PostgreSQLParserSESSION, PostgreSQLParserSET, PostgreSQLParserSHARE, PostgreSQLParserSHOW, PostgreSQLParserSIMPLE, PostgreSQLParserSNAPSHOT, PostgreSQLParserSTABLE, PostgreSQLParserSTANDALONE_P, PostgreSQLParserSTART, PostgreSQLParserSTATEMENT, PostgreSQLParserSTATISTICS, PostgreSQLParserSTDIN, PostgreSQLParserSTDOUT, PostgreSQLParserSTORAGE, PostgreSQLParserSTRICT_P, PostgreSQLParserSTRIP_P, PostgreSQLParserSYSID, PostgreSQLParserSYSTEM_P, PostgreSQLParserTABLES, PostgreSQLParserTABLESPACE, PostgreSQLParserTEMP, PostgreSQLParserTEMPLATE, PostgreSQLParserTEMPORARY, PostgreSQLParserTEXT_P, PostgreSQLParserTRANSACTION, PostgreSQLParserTRIGGER, PostgreSQLParserTRUNCATE, PostgreSQLParserTRUSTED, PostgreSQLParserTYPE_P, PostgreSQLParserTYPES_P, PostgreSQLParserUNBOUNDED, PostgreSQLParserUNCOMMITTED, PostgreSQLParserUNENCRYPTED, PostgreSQLParserUNKNOWN, PostgreSQLParserUNLISTEN, PostgreSQLParserUNLOGGED, PostgreSQLParserUNTIL, PostgreSQLParserUPDATE, PostgreSQLParserVACUUM, PostgreSQLParserVALID, PostgreSQLParserVALIDATE, PostgreSQLParserVALIDATOR, PostgreSQLParserVARYING, PostgreSQLParserVERSION_P, PostgreSQLParserVIEW, PostgreSQLParserVOLATILE, PostgreSQLParserWHITESPACE_P, PostgreSQLParserWITHOUT, PostgreSQLParserWORK, PostgreSQLParserWRAPPER, PostgreSQLParserWRITE, PostgreSQLParserXML_P, PostgreSQLParserYEAR_P, PostgreSQLParserYES_P, PostgreSQLParserZONE, PostgreSQLParserBETWEEN, PostgreSQLParserBIGINT, PostgreSQLParserBIT, PostgreSQLParserBOOLEAN_P, PostgreSQLParserCHAR_P, PostgreSQLParserCHARACTER, PostgreSQLParserCOALESCE, PostgreSQLParserDEC, PostgreSQLParserDECIMAL_P, PostgreSQLParserEXISTS, PostgreSQLParserEXTRACT, PostgreSQLParserFLOAT_P, PostgreSQLParserGREATEST, PostgreSQLParserINOUT, PostgreSQLParserINT_P, PostgreSQLParserINTEGER, PostgreSQLParserINTERVAL, PostgreSQLParserLEAST, PostgreSQLParserNATIONAL, PostgreSQLParserNCHAR, PostgreSQLParserNONE, PostgreSQLParserNULLIF, PostgreSQLParserNUMERIC, PostgreSQLParserOVERLAY, PostgreSQLParserPOSITION, PostgreSQLParserPRECISION, PostgreSQLParserREAL, PostgreSQLParserROW, PostgreSQLParserSETOF, PostgreSQLParserSMALLINT, PostgreSQLParserSUBSTRING, PostgreSQLParserTIME, PostgreSQLParserTIMESTAMP, PostgreSQLParserTREAT, PostgreSQLParserTRIM, PostgreSQLParserVALUES, PostgreSQLParserVARCHAR, PostgreSQLParserXMLATTRIBUTES, PostgreSQLParserXMLCOMMENT, PostgreSQLParserXMLAGG, PostgreSQLParserXML_IS_WELL_FORMED, PostgreSQLParserXML_IS_WELL_FORMED_DOCUMENT, PostgreSQLParserXML_IS_WELL_FORMED_CONTENT, PostgreSQLParserXPATH, PostgreSQLParserXPATH_EXISTS, PostgreSQLParserXMLCONCAT, PostgreSQLParserXMLELEMENT, PostgreSQLParserXMLEXISTS, PostgreSQLParserXMLFOREST, PostgreSQLParserXMLPARSE, PostgreSQLParserXMLPI, PostgreSQLParserXMLROOT, PostgreSQLParserXMLSERIALIZE, PostgreSQLParserCALL, PostgreSQLParserCURRENT_P, PostgreSQLParserATTACH, PostgreSQLParserDETACH, PostgreSQLParserEXPRESSION, PostgreSQLParserGENERATED, PostgreSQLParserLOGGED, PostgreSQLParserSTORED, PostgreSQLParserINCLUDE, PostgreSQLParserROUTINE, PostgreSQLParserTRANSFORM, PostgreSQLParserIMPORT_P, PostgreSQLParserPOLICY, PostgreSQLParserMETHOD, PostgreSQLParserREFERENCING, PostgreSQLParserNEW, PostgreSQLParserOLD, PostgreSQLParserVALUE_P, PostgreSQLParserSUBSCRIPTION, PostgreSQLParserPUBLICATION, PostgreSQLParserOUT_P, PostgreSQLParserROUTINES, PostgreSQLParserSCHEMAS, PostgreSQLParserPROCEDURES, PostgreSQLParserINPUT_P, PostgreSQLParserSUPPORT, PostgreSQLParserPARALLEL, PostgreSQLParserSQL_P, PostgreSQLParserDEPENDS, PostgreSQLParserOVERRIDING, PostgreSQLParserCONFLICT, PostgreSQLParserSKIP_P, PostgreSQLParserLOCKED, PostgreSQLParserTIES, PostgreSQLParserROLLUP, PostgreSQLParserCUBE, PostgreSQLParserGROUPING, PostgreSQLParserSETS, PostgreSQLParserORDINALITY, PostgreSQLParserXMLTABLE, PostgreSQLParserCOLUMNS, PostgreSQLParserXMLNAMESPACES, PostgreSQLParserROWTYPE, PostgreSQLParserNORMALIZED, PostgreSQLParserWITHIN, PostgreSQLParserFILTER, PostgreSQLParserGROUPS, PostgreSQLParserOTHERS, PostgreSQLParserNFC, PostgreSQLParserNFD, PostgreSQLParserNFKC, PostgreSQLParserNFKD, PostgreSQLParserUESCAPE, PostgreSQLParserVIEWS, PostgreSQLParserNORMALIZE, PostgreSQLParserDUMP, PostgreSQLParserPRINT_STRICT_PARAMS, PostgreSQLParserVARIABLE_CONFLICT, PostgreSQLParserERROR, PostgreSQLParserUSE_VARIABLE, PostgreSQLParserUSE_COLUMN, PostgreSQLParserALIAS, PostgreSQLParserCONSTANT, PostgreSQLParserPERFORM, PostgreSQLParserGET, PostgreSQLParserDIAGNOSTICS, PostgreSQLParserSTACKED, PostgreSQLParserELSIF, PostgreSQLParserREVERSE, PostgreSQLParserSLICE, PostgreSQLParserEXIT, PostgreSQLParserRETURN, PostgreSQLParserQUERY, PostgreSQLParserRAISE, PostgreSQLParserSQLSTATE, PostgreSQLParserDEBUG, PostgreSQLParserLOG, PostgreSQLParserINFO, PostgreSQLParserNOTICE, PostgreSQLParserWARNING, PostgreSQLParserEXCEPTION, PostgreSQLParserASSERT, PostgreSQLParserOPEN, PostgreSQLParserABS, PostgreSQLParserCBRT, PostgreSQLParserCEIL, PostgreSQLParserCEILING, PostgreSQLParserDEGREES, PostgreSQLParserDIV, PostgreSQLParserEXP, PostgreSQLParserFACTORIAL, PostgreSQLParserFLOOR, PostgreSQLParserGCD, PostgreSQLParserLCM, PostgreSQLParserLN, PostgreSQLParserLOG10, PostgreSQLParserMIN_SCALE, PostgreSQLParserMOD, PostgreSQLParserPI, PostgreSQLParserPOWER, PostgreSQLParserRADIANS, PostgreSQLParserROUND, PostgreSQLParserSCALE, PostgreSQLParserSIGN, PostgreSQLParserSQRT, PostgreSQLParserTRIM_SCALE, PostgreSQLParserTRUNC, PostgreSQLParserWIDTH_BUCKET, PostgreSQLParserRANDOM, PostgreSQLParserSETSEED, PostgreSQLParserACOS, PostgreSQLParserACOSD, PostgreSQLParserASIN, PostgreSQLParserASIND, PostgreSQLParserATAN, PostgreSQLParserATAND, PostgreSQLParserATAN2, PostgreSQLParserATAN2D, PostgreSQLParserCOS, PostgreSQLParserCOSD, PostgreSQLParserCOT, PostgreSQLParserCOTD, PostgreSQLParserSIN, PostgreSQLParserSIND, PostgreSQLParserTAN, PostgreSQLParserTAND, PostgreSQLParserSINH, PostgreSQLParserCOSH, PostgreSQLParserTANH, PostgreSQLParserASINH, PostgreSQLParserACOSH, PostgreSQLParserATANH, PostgreSQLParserBIT_LENGTH, PostgreSQLParserCHAR_LENGTH, PostgreSQLParserCHARACTER_LENGTH, PostgreSQLParserLOWER, PostgreSQLParserOCTET_LENGTH, PostgreSQLParserUPPER, PostgreSQLParserASCII, PostgreSQLParserBTRIM, PostgreSQLParserCHR, PostgreSQLParserCONCAT, PostgreSQLParserCONCAT_WS, PostgreSQLParserFORMAT, PostgreSQLParserINITCAP, PostgreSQLParserLENGTH, PostgreSQLParserLPAD, PostgreSQLParserLTRIM, PostgreSQLParserMD5, PostgreSQLParserPARSE_IDENT, PostgreSQLParserPG_CLIENT_ENCODING, PostgreSQLParserQUOTE_IDENT, PostgreSQLParserQUOTE_LITERAL, PostgreSQLParserQUOTE_NULLABLE, PostgreSQLParserREGEXP_COUNT, PostgreSQLParserREGEXP_INSTR, PostgreSQLParserREGEXP_LIKE, PostgreSQLParserREGEXP_MATCH, PostgreSQLParserREGEXP_MATCHES, PostgreSQLParserREGEXP_REPLACE, PostgreSQLParserREGEXP_SPLIT_TO_ARRAY, PostgreSQLParserREGEXP_SPLIT_TO_TABLE, PostgreSQLParserREGEXP_SUBSTR, PostgreSQLParserREPEAT, PostgreSQLParserRPAD, PostgreSQLParserRTRIM, PostgreSQLParserSPLIT_PART, PostgreSQLParserSTARTS_WITH, PostgreSQLParserSTRING_TO_ARRAY, PostgreSQLParserSTRING_TO_TABLE, PostgreSQLParserSTRPOS, PostgreSQLParserSUBSTR, PostgreSQLParserTO_ASCII, PostgreSQLParserTO_HEX, PostgreSQLParserTRANSLATE, PostgreSQLParserUNISTR, PostgreSQLParserAGE, PostgreSQLParserCLOCK_TIMESTAMP, PostgreSQLParserDATE_BIN, PostgreSQLParserDATE_PART, PostgreSQLParserDATE_TRUNC, PostgreSQLParserISFINITE, PostgreSQLParserJUSTIFY_DAYS, PostgreSQLParserJUSTIFY_HOURS, PostgreSQLParserJUSTIFY_INTERVAL, PostgreSQLParserMAKE_DATE, PostgreSQLParserMAKE_INTERVAL, PostgreSQLParserMAKE_TIME, PostgreSQLParserMAKE_TIMESTAMP, PostgreSQLParserMAKE_TIMESTAMPTZ, PostgreSQLParserNOW, PostgreSQLParserSTATEMENT_TIMESTAMP, PostgreSQLParserTIMEOFDAY, PostgreSQLParserTRANSACTION_TIMESTAMP, PostgreSQLParserTO_TIMESTAMP, PostgreSQLParserTO_CHAR, PostgreSQLParserTO_DATE, PostgreSQLParserTO_NUMBER, PostgreSQLParserIdentifier, PostgreSQLParserQuotedIdentifier, PostgreSQLParserUnicodeQuotedIdentifier, PostgreSQLParserPLSQLVARIABLENAME, PostgreSQLParserPLSQLIDENTIFIER:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(5283)
			p.Name()
		}

	case PostgreSQLParserON:
		p.EnterOuterAlt(localctx, 2)

	default:
		p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IAccess_method_clauseContext is an interface to support dynamic dispatch.
type IAccess_method_clauseContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	USING() antlr.TerminalNode
	Name() INameContext

	// IsAccess_method_clauseContext differentiates from other interfaces.
	IsAccess_method_clauseContext()
}

type Access_method_clauseContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyAccess_method_clauseContext() *Access_method_clauseContext {
	var p = new(Access_method_clauseContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_access_method_clause
	return p
}

func InitEmptyAccess_method_clauseContext(p *Access_method_clauseContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_access_method_clause
}

func (*Access_method_clauseContext) IsAccess_method_clauseContext() {}

func NewAccess_method_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Access_method_clauseContext {
	var p = new(Access_method_clauseContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_access_method_clause

	return p
}

func (s *Access_method_clauseContext) GetParser() antlr.Parser { return s.parser }

func (s *Access_method_clauseContext) USING() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserUSING, 0)
}

func (s *Access_method_clauseContext) Name() INameContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(INameContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(INameContext)
}

func (s *Access_method_clauseContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Access_method_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Access_method_clauseContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterAccess_method_clause(s)
	}
}

func (s *Access_method_clauseContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitAccess_method_clause(s)
	}
}

func (s *Access_method_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitAccess_method_clause(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Access_method_clause() (localctx IAccess_method_clauseContext) {
	localctx = NewAccess_method_clauseContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 596, PostgreSQLParserRULE_access_method_clause)
	p.SetState(5290)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetTokenStream().LA(1) {
	case PostgreSQLParserUSING:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(5287)
			p.Match(PostgreSQLParserUSING)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5288)
			p.Name()
		}

	case PostgreSQLParserOPEN_PAREN:
		p.EnterOuterAlt(localctx, 2)

	default:
		p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IIndex_paramsContext is an interface to support dynamic dispatch.
type IIndex_paramsContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	AllIndex_elem() []IIndex_elemContext
	Index_elem(i int) IIndex_elemContext
	AllCOMMA() []antlr.TerminalNode
	COMMA(i int) antlr.TerminalNode

	// IsIndex_paramsContext differentiates from other interfaces.
	IsIndex_paramsContext()
}

type Index_paramsContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyIndex_paramsContext() *Index_paramsContext {
	var p = new(Index_paramsContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_index_params
	return p
}

func InitEmptyIndex_paramsContext(p *Index_paramsContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_index_params
}

func (*Index_paramsContext) IsIndex_paramsContext() {}

func NewIndex_paramsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Index_paramsContext {
	var p = new(Index_paramsContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_index_params

	return p
}

func (s *Index_paramsContext) GetParser() antlr.Parser { return s.parser }

func (s *Index_paramsContext) AllIndex_elem() []IIndex_elemContext {
	children := s.GetChildren()
	len := 0
	for _, ctx := range children {
		if _, ok := ctx.(IIndex_elemContext); ok {
			len++
		}
	}

	tst := make([]IIndex_elemContext, len)
	i := 0
	for _, ctx := range children {
		if t, ok := ctx.(IIndex_elemContext); ok {
			tst[i] = t.(IIndex_elemContext)
			i++
		}
	}

	return tst
}

func (s *Index_paramsContext) Index_elem(i int) IIndex_elemContext {
	var t antlr.RuleContext
	j := 0
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IIndex_elemContext); ok {
			if j == i {
				t = ctx.(antlr.RuleContext)
				break
			}
			j++
		}
	}

	if t == nil {
		return nil
	}

	return t.(IIndex_elemContext)
}

func (s *Index_paramsContext) AllCOMMA() []antlr.TerminalNode {
	return s.GetTokens(PostgreSQLParserCOMMA)
}

func (s *Index_paramsContext) COMMA(i int) antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCOMMA, i)
}

func (s *Index_paramsContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Index_paramsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Index_paramsContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterIndex_params(s)
	}
}

func (s *Index_paramsContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitIndex_params(s)
	}
}

func (s *Index_paramsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitIndex_params(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Index_params() (localctx IIndex_paramsContext) {
	localctx = NewIndex_paramsContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 598, PostgreSQLParserRULE_index_params)
	var _la int

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(5292)
		p.Index_elem()
	}
	p.SetState(5297)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}
	_la = p.GetTokenStream().LA(1)

	for _la == PostgreSQLParserCOMMA {
		{
			p.SetState(5293)
			p.Match(PostgreSQLParserCOMMA)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5294)
			p.Index_elem()
		}

		p.SetState(5299)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}
		_la = p.GetTokenStream().LA(1)
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IIndex_elem_optionsContext is an interface to support dynamic dispatch.
type IIndex_elem_optionsContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Opt_collate() IOpt_collateContext
	Opt_class() IOpt_classContext
	Opt_asc_desc() IOpt_asc_descContext
	Opt_nulls_order() IOpt_nulls_orderContext
	Any_name() IAny_nameContext
	Reloptions() IReloptionsContext

	// IsIndex_elem_optionsContext differentiates from other interfaces.
	IsIndex_elem_optionsContext()
}

type Index_elem_optionsContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyIndex_elem_optionsContext() *Index_elem_optionsContext {
	var p = new(Index_elem_optionsContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_index_elem_options
	return p
}

func InitEmptyIndex_elem_optionsContext(p *Index_elem_optionsContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_index_elem_options
}

func (*Index_elem_optionsContext) IsIndex_elem_optionsContext() {}

func NewIndex_elem_optionsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Index_elem_optionsContext {
	var p = new(Index_elem_optionsContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_index_elem_options

	return p
}

func (s *Index_elem_optionsContext) GetParser() antlr.Parser { return s.parser }

func (s *Index_elem_optionsContext) Opt_collate() IOpt_collateContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOpt_collateContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOpt_collateContext)
}

func (s *Index_elem_optionsContext) Opt_class() IOpt_classContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOpt_classContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOpt_classContext)
}

func (s *Index_elem_optionsContext) Opt_asc_desc() IOpt_asc_descContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOpt_asc_descContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOpt_asc_descContext)
}

func (s *Index_elem_optionsContext) Opt_nulls_order() IOpt_nulls_orderContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOpt_nulls_orderContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOpt_nulls_orderContext)
}

func (s *Index_elem_optionsContext) Any_name() IAny_nameContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IAny_nameContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IAny_nameContext)
}

func (s *Index_elem_optionsContext) Reloptions() IReloptionsContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IReloptionsContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IReloptionsContext)
}

func (s *Index_elem_optionsContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Index_elem_optionsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Index_elem_optionsContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterIndex_elem_options(s)
	}
}

func (s *Index_elem_optionsContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitIndex_elem_options(s)
	}
}

func (s *Index_elem_optionsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitIndex_elem_options(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Index_elem_options() (localctx IIndex_elem_optionsContext) {
	localctx = NewIndex_elem_optionsContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 600, PostgreSQLParserRULE_index_elem_options)
	p.SetState(5311)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 255, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(5300)
			p.Opt_collate()
		}
		{
			p.SetState(5301)
			p.Opt_class()
		}
		{
			p.SetState(5302)
			p.Opt_asc_desc()
		}
		{
			p.SetState(5303)
			p.Opt_nulls_order()
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(5305)
			p.Opt_collate()
		}
		{
			p.SetState(5306)
			p.Any_name()
		}
		{
			p.SetState(5307)
			p.Reloptions()
		}
		{
			p.SetState(5308)
			p.Opt_asc_desc()
		}
		{
			p.SetState(5309)
			p.Opt_nulls_order()
		}

	case antlr.ATNInvalidAltNumber:
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IIndex_elemContext is an interface to support dynamic dispatch.
type IIndex_elemContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Colid() IColidContext
	Index_elem_options() IIndex_elem_optionsContext
	Func_expr_windowless() IFunc_expr_windowlessContext
	OPEN_PAREN() antlr.TerminalNode
	A_expr() IA_exprContext
	CLOSE_PAREN() antlr.TerminalNode

	// IsIndex_elemContext differentiates from other interfaces.
	IsIndex_elemContext()
}

type Index_elemContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyIndex_elemContext() *Index_elemContext {
	var p = new(Index_elemContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_index_elem
	return p
}

func InitEmptyIndex_elemContext(p *Index_elemContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_index_elem
}

func (*Index_elemContext) IsIndex_elemContext() {}

func NewIndex_elemContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Index_elemContext {
	var p = new(Index_elemContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_index_elem

	return p
}

func (s *Index_elemContext) GetParser() antlr.Parser { return s.parser }

func (s *Index_elemContext) Colid() IColidContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IColidContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IColidContext)
}

func (s *Index_elemContext) Index_elem_options() IIndex_elem_optionsContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IIndex_elem_optionsContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IIndex_elem_optionsContext)
}

func (s *Index_elemContext) Func_expr_windowless() IFunc_expr_windowlessContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IFunc_expr_windowlessContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IFunc_expr_windowlessContext)
}

func (s *Index_elemContext) OPEN_PAREN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserOPEN_PAREN, 0)
}

func (s *Index_elemContext) A_expr() IA_exprContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IA_exprContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IA_exprContext)
}

func (s *Index_elemContext) CLOSE_PAREN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCLOSE_PAREN, 0)
}

func (s *Index_elemContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Index_elemContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Index_elemContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterIndex_elem(s)
	}
}

func (s *Index_elemContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitIndex_elem(s)
	}
}

func (s *Index_elemContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitIndex_elem(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Index_elem() (localctx IIndex_elemContext) {
	localctx = NewIndex_elemContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 602, PostgreSQLParserRULE_index_elem)
	p.SetState(5324)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 256, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(5313)
			p.Colid()
		}
		{
			p.SetState(5314)
			p.Index_elem_options()
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(5316)
			p.Func_expr_windowless()
		}
		{
			p.SetState(5317)
			p.Index_elem_options()
		}

	case 3:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(5319)
			p.Match(PostgreSQLParserOPEN_PAREN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5320)
			p.A_expr()
		}
		{
			p.SetState(5321)
			p.Match(PostgreSQLParserCLOSE_PAREN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5322)
			p.Index_elem_options()
		}

	case antlr.ATNInvalidAltNumber:
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IOpt_includeContext is an interface to support dynamic dispatch.
type IOpt_includeContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	INCLUDE() antlr.TerminalNode
	OPEN_PAREN() antlr.TerminalNode
	Index_including_params() IIndex_including_paramsContext
	CLOSE_PAREN() antlr.TerminalNode

	// IsOpt_includeContext differentiates from other interfaces.
	IsOpt_includeContext()
}

type Opt_includeContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyOpt_includeContext() *Opt_includeContext {
	var p = new(Opt_includeContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opt_include
	return p
}

func InitEmptyOpt_includeContext(p *Opt_includeContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opt_include
}

func (*Opt_includeContext) IsOpt_includeContext() {}

func NewOpt_includeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_includeContext {
	var p = new(Opt_includeContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_opt_include

	return p
}

func (s *Opt_includeContext) GetParser() antlr.Parser { return s.parser }

func (s *Opt_includeContext) INCLUDE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserINCLUDE, 0)
}

func (s *Opt_includeContext) OPEN_PAREN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserOPEN_PAREN, 0)
}

func (s *Opt_includeContext) Index_including_params() IIndex_including_paramsContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IIndex_including_paramsContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IIndex_including_paramsContext)
}

func (s *Opt_includeContext) CLOSE_PAREN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCLOSE_PAREN, 0)
}

func (s *Opt_includeContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Opt_includeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Opt_includeContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterOpt_include(s)
	}
}

func (s *Opt_includeContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitOpt_include(s)
	}
}

func (s *Opt_includeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitOpt_include(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Opt_include() (localctx IOpt_includeContext) {
	localctx = NewOpt_includeContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 604, PostgreSQLParserRULE_opt_include)
	p.SetState(5332)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetTokenStream().LA(1) {
	case PostgreSQLParserINCLUDE:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(5326)
			p.Match(PostgreSQLParserINCLUDE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5327)
			p.Match(PostgreSQLParserOPEN_PAREN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5328)
			p.Index_including_params()
		}
		{
			p.SetState(5329)
			p.Match(PostgreSQLParserCLOSE_PAREN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case PostgreSQLParserEOF, PostgreSQLParserOPEN_PAREN, PostgreSQLParserSEMI, PostgreSQLParserANALYSE, PostgreSQLParserANALYZE, PostgreSQLParserCREATE, PostgreSQLParserDO, PostgreSQLParserFETCH, PostgreSQLParserGRANT, PostgreSQLParserINTO, PostgreSQLParserSELECT, PostgreSQLParserTABLE, PostgreSQLParserWHERE, PostgreSQLParserWITH, PostgreSQLParserABORT_P, PostgreSQLParserALTER, PostgreSQLParserBEGIN_P, PostgreSQLParserCHECKPOINT, PostgreSQLParserCLOSE, PostgreSQLParserCLUSTER, PostgreSQLParserCOMMENT, PostgreSQLParserCOMMIT, PostgreSQLParserCOPY, PostgreSQLParserDEALLOCATE, PostgreSQLParserDECLARE, PostgreSQLParserDELETE_P, PostgreSQLParserDISCARD, PostgreSQLParserDROP, PostgreSQLParserEXECUTE, PostgreSQLParserEXPLAIN, PostgreSQLParserINSERT, PostgreSQLParserLISTEN, PostgreSQLParserLOAD, PostgreSQLParserLOCK_P, PostgreSQLParserMERGE, PostgreSQLParserMOVE, PostgreSQLParserNOTIFY, PostgreSQLParserPREPARE, PostgreSQLParserREASSIGN, PostgreSQLParserREFRESH, PostgreSQLParserREINDEX, PostgreSQLParserRELEASE, PostgreSQLParserRESET, PostgreSQLParserREVOKE, PostgreSQLParserROLLBACK, PostgreSQLParserSAVEPOINT, PostgreSQLParserSECURITY, PostgreSQLParserSET, PostgreSQLParserSHOW, PostgreSQLParserSTART, PostgreSQLParserTABLESPACE, PostgreSQLParserTRUNCATE, PostgreSQLParserUNLISTEN, PostgreSQLParserUPDATE, PostgreSQLParserVACUUM, PostgreSQLParserVALUES, PostgreSQLParserCALL, PostgreSQLParserIMPORT_P, PostgreSQLParserEND_P, PostgreSQLParserMetaCommand:
		p.EnterOuterAlt(localctx, 2)

	default:
		p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IIndex_including_paramsContext is an interface to support dynamic dispatch.
type IIndex_including_paramsContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	AllIndex_elem() []IIndex_elemContext
	Index_elem(i int) IIndex_elemContext
	AllCOMMA() []antlr.TerminalNode
	COMMA(i int) antlr.TerminalNode

	// IsIndex_including_paramsContext differentiates from other interfaces.
	IsIndex_including_paramsContext()
}

type Index_including_paramsContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyIndex_including_paramsContext() *Index_including_paramsContext {
	var p = new(Index_including_paramsContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_index_including_params
	return p
}

func InitEmptyIndex_including_paramsContext(p *Index_including_paramsContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_index_including_params
}

func (*Index_including_paramsContext) IsIndex_including_paramsContext() {}

func NewIndex_including_paramsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Index_including_paramsContext {
	var p = new(Index_including_paramsContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_index_including_params

	return p
}

func (s *Index_including_paramsContext) GetParser() antlr.Parser { return s.parser }

func (s *Index_including_paramsContext) AllIndex_elem() []IIndex_elemContext {
	children := s.GetChildren()
	len := 0
	for _, ctx := range children {
		if _, ok := ctx.(IIndex_elemContext); ok {
			len++
		}
	}

	tst := make([]IIndex_elemContext, len)
	i := 0
	for _, ctx := range children {
		if t, ok := ctx.(IIndex_elemContext); ok {
			tst[i] = t.(IIndex_elemContext)
			i++
		}
	}

	return tst
}

func (s *Index_including_paramsContext) Index_elem(i int) IIndex_elemContext {
	var t antlr.RuleContext
	j := 0
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IIndex_elemContext); ok {
			if j == i {
				t = ctx.(antlr.RuleContext)
				break
			}
			j++
		}
	}

	if t == nil {
		return nil
	}

	return t.(IIndex_elemContext)
}

func (s *Index_including_paramsContext) AllCOMMA() []antlr.TerminalNode {
	return s.GetTokens(PostgreSQLParserCOMMA)
}

func (s *Index_including_paramsContext) COMMA(i int) antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCOMMA, i)
}

func (s *Index_including_paramsContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Index_including_paramsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Index_including_paramsContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterIndex_including_params(s)
	}
}

func (s *Index_including_paramsContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitIndex_including_params(s)
	}
}

func (s *Index_including_paramsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitIndex_including_params(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Index_including_params() (localctx IIndex_including_paramsContext) {
	localctx = NewIndex_including_paramsContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 606, PostgreSQLParserRULE_index_including_params)
	var _la int

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(5334)
		p.Index_elem()
	}
	p.SetState(5339)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}
	_la = p.GetTokenStream().LA(1)

	for _la == PostgreSQLParserCOMMA {
		{
			p.SetState(5335)
			p.Match(PostgreSQLParserCOMMA)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5336)
			p.Index_elem()
		}

		p.SetState(5341)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}
		_la = p.GetTokenStream().LA(1)
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IOpt_collateContext is an interface to support dynamic dispatch.
type IOpt_collateContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	COLLATE() antlr.TerminalNode
	Any_name() IAny_nameContext

	// IsOpt_collateContext differentiates from other interfaces.
	IsOpt_collateContext()
}

type Opt_collateContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyOpt_collateContext() *Opt_collateContext {
	var p = new(Opt_collateContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opt_collate
	return p
}

func InitEmptyOpt_collateContext(p *Opt_collateContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opt_collate
}

func (*Opt_collateContext) IsOpt_collateContext() {}

func NewOpt_collateContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_collateContext {
	var p = new(Opt_collateContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_opt_collate

	return p
}

func (s *Opt_collateContext) GetParser() antlr.Parser { return s.parser }

func (s *Opt_collateContext) COLLATE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCOLLATE, 0)
}

func (s *Opt_collateContext) Any_name() IAny_nameContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IAny_nameContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IAny_nameContext)
}

func (s *Opt_collateContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Opt_collateContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Opt_collateContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterOpt_collate(s)
	}
}

func (s *Opt_collateContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitOpt_collate(s)
	}
}

func (s *Opt_collateContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitOpt_collate(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Opt_collate() (localctx IOpt_collateContext) {
	localctx = NewOpt_collateContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 608, PostgreSQLParserRULE_opt_collate)
	p.SetState(5345)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 259, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(5342)
			p.Match(PostgreSQLParserCOLLATE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5343)
			p.Any_name()
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)

	case antlr.ATNInvalidAltNumber:
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IOpt_classContext is an interface to support dynamic dispatch.
type IOpt_classContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Any_name() IAny_nameContext

	// IsOpt_classContext differentiates from other interfaces.
	IsOpt_classContext()
}

type Opt_classContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyOpt_classContext() *Opt_classContext {
	var p = new(Opt_classContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opt_class
	return p
}

func InitEmptyOpt_classContext(p *Opt_classContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opt_class
}

func (*Opt_classContext) IsOpt_classContext() {}

func NewOpt_classContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_classContext {
	var p = new(Opt_classContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_opt_class

	return p
}

func (s *Opt_classContext) GetParser() antlr.Parser { return s.parser }

func (s *Opt_classContext) Any_name() IAny_nameContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IAny_nameContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IAny_nameContext)
}

func (s *Opt_classContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Opt_classContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Opt_classContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterOpt_class(s)
	}
}

func (s *Opt_classContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitOpt_class(s)
	}
}

func (s *Opt_classContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitOpt_class(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Opt_class() (localctx IOpt_classContext) {
	localctx = NewOpt_classContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 610, PostgreSQLParserRULE_opt_class)
	p.SetState(5349)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 260, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(5347)
			p.Any_name()
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)

	case antlr.ATNInvalidAltNumber:
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IOpt_asc_descContext is an interface to support dynamic dispatch.
type IOpt_asc_descContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	ASC() antlr.TerminalNode
	DESC() antlr.TerminalNode

	// IsOpt_asc_descContext differentiates from other interfaces.
	IsOpt_asc_descContext()
}

type Opt_asc_descContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyOpt_asc_descContext() *Opt_asc_descContext {
	var p = new(Opt_asc_descContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opt_asc_desc
	return p
}

func InitEmptyOpt_asc_descContext(p *Opt_asc_descContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opt_asc_desc
}

func (*Opt_asc_descContext) IsOpt_asc_descContext() {}

func NewOpt_asc_descContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_asc_descContext {
	var p = new(Opt_asc_descContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_opt_asc_desc

	return p
}

func (s *Opt_asc_descContext) GetParser() antlr.Parser { return s.parser }

func (s *Opt_asc_descContext) ASC() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserASC, 0)
}

func (s *Opt_asc_descContext) DESC() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserDESC, 0)
}

func (s *Opt_asc_descContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Opt_asc_descContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Opt_asc_descContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterOpt_asc_desc(s)
	}
}

func (s *Opt_asc_descContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitOpt_asc_desc(s)
	}
}

func (s *Opt_asc_descContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitOpt_asc_desc(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Opt_asc_desc() (localctx IOpt_asc_descContext) {
	localctx = NewOpt_asc_descContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 612, PostgreSQLParserRULE_opt_asc_desc)
	p.SetState(5354)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetTokenStream().LA(1) {
	case PostgreSQLParserASC:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(5351)
			p.Match(PostgreSQLParserASC)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case PostgreSQLParserDESC:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(5352)
			p.Match(PostgreSQLParserDESC)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case PostgreSQLParserEOF, PostgreSQLParserOPEN_PAREN, PostgreSQLParserCLOSE_PAREN, PostgreSQLParserCOMMA, PostgreSQLParserSEMI, PostgreSQLParserANALYSE, PostgreSQLParserANALYZE, PostgreSQLParserCREATE, PostgreSQLParserDO, PostgreSQLParserFETCH, PostgreSQLParserFOR, PostgreSQLParserGRANT, PostgreSQLParserINTO, PostgreSQLParserLIMIT, PostgreSQLParserOFFSET, PostgreSQLParserON, PostgreSQLParserRETURNING, PostgreSQLParserSELECT, PostgreSQLParserTABLE, PostgreSQLParserWITH, PostgreSQLParserABORT_P, PostgreSQLParserALTER, PostgreSQLParserBEGIN_P, PostgreSQLParserCHECKPOINT, PostgreSQLParserCLOSE, PostgreSQLParserCLUSTER, PostgreSQLParserCOMMENT, PostgreSQLParserCOMMIT, PostgreSQLParserCOPY, PostgreSQLParserDEALLOCATE, PostgreSQLParserDECLARE, PostgreSQLParserDELETE_P, PostgreSQLParserDISCARD, PostgreSQLParserDROP, PostgreSQLParserEXECUTE, PostgreSQLParserEXPLAIN, PostgreSQLParserINSERT, PostgreSQLParserLISTEN, PostgreSQLParserLOAD, PostgreSQLParserLOCK_P, PostgreSQLParserMERGE, PostgreSQLParserMOVE, PostgreSQLParserNOTIFY, PostgreSQLParserNULLS_P, PostgreSQLParserPREPARE, PostgreSQLParserRANGE, PostgreSQLParserREASSIGN, PostgreSQLParserREFRESH, PostgreSQLParserREINDEX, PostgreSQLParserRELEASE, PostgreSQLParserRESET, PostgreSQLParserREVOKE, PostgreSQLParserROLLBACK, PostgreSQLParserROWS, PostgreSQLParserSAVEPOINT, PostgreSQLParserSECURITY, PostgreSQLParserSET, PostgreSQLParserSHOW, PostgreSQLParserSTART, PostgreSQLParserTRUNCATE, PostgreSQLParserUNLISTEN, PostgreSQLParserUPDATE, PostgreSQLParserVACUUM, PostgreSQLParserVALUES, PostgreSQLParserCALL, PostgreSQLParserIMPORT_P, PostgreSQLParserEND_P, PostgreSQLParserGROUPS, PostgreSQLParserLOOP, PostgreSQLParserMetaCommand:
		p.EnterOuterAlt(localctx, 3)

	default:
		p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IOpt_nulls_orderContext is an interface to support dynamic dispatch.
type IOpt_nulls_orderContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	NULLS_P() antlr.TerminalNode
	FIRST_P() antlr.TerminalNode
	LAST_P() antlr.TerminalNode

	// IsOpt_nulls_orderContext differentiates from other interfaces.
	IsOpt_nulls_orderContext()
}

type Opt_nulls_orderContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyOpt_nulls_orderContext() *Opt_nulls_orderContext {
	var p = new(Opt_nulls_orderContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opt_nulls_order
	return p
}

func InitEmptyOpt_nulls_orderContext(p *Opt_nulls_orderContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opt_nulls_order
}

func (*Opt_nulls_orderContext) IsOpt_nulls_orderContext() {}

func NewOpt_nulls_orderContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_nulls_orderContext {
	var p = new(Opt_nulls_orderContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_opt_nulls_order

	return p
}

func (s *Opt_nulls_orderContext) GetParser() antlr.Parser { return s.parser }

func (s *Opt_nulls_orderContext) NULLS_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserNULLS_P, 0)
}

func (s *Opt_nulls_orderContext) FIRST_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserFIRST_P, 0)
}

func (s *Opt_nulls_orderContext) LAST_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserLAST_P, 0)
}

func (s *Opt_nulls_orderContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Opt_nulls_orderContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Opt_nulls_orderContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterOpt_nulls_order(s)
	}
}

func (s *Opt_nulls_orderContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitOpt_nulls_order(s)
	}
}

func (s *Opt_nulls_orderContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitOpt_nulls_order(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Opt_nulls_order() (localctx IOpt_nulls_orderContext) {
	localctx = NewOpt_nulls_orderContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 614, PostgreSQLParserRULE_opt_nulls_order)
	p.SetState(5361)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 262, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(5356)
			p.Match(PostgreSQLParserNULLS_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5357)
			p.Match(PostgreSQLParserFIRST_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(5358)
			p.Match(PostgreSQLParserNULLS_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5359)
			p.Match(PostgreSQLParserLAST_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 3:
		p.EnterOuterAlt(localctx, 3)

	case antlr.ATNInvalidAltNumber:
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// ICreatefunctionstmtContext is an interface to support dynamic dispatch.
type ICreatefunctionstmtContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	CREATE() antlr.TerminalNode
	Opt_or_replace() IOpt_or_replaceContext
	Func_name() IFunc_nameContext
	Func_args_with_defaults() IFunc_args_with_defaultsContext
	Createfunc_opt_list() ICreatefunc_opt_listContext
	FUNCTION() antlr.TerminalNode
	PROCEDURE() antlr.TerminalNode
	RETURNS() antlr.TerminalNode
	Func_return() IFunc_returnContext
	TABLE() antlr.TerminalNode
	OPEN_PAREN() antlr.TerminalNode
	Table_func_column_list() ITable_func_column_listContext
	CLOSE_PAREN() antlr.TerminalNode

	// IsCreatefunctionstmtContext differentiates from other interfaces.
	IsCreatefunctionstmtContext()
}

type CreatefunctionstmtContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyCreatefunctionstmtContext() *CreatefunctionstmtContext {
	var p = new(CreatefunctionstmtContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_createfunctionstmt
	return p
}

func InitEmptyCreatefunctionstmtContext(p *CreatefunctionstmtContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_createfunctionstmt
}

func (*CreatefunctionstmtContext) IsCreatefunctionstmtContext() {}

func NewCreatefunctionstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CreatefunctionstmtContext {
	var p = new(CreatefunctionstmtContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_createfunctionstmt

	return p
}

func (s *CreatefunctionstmtContext) GetParser() antlr.Parser { return s.parser }

func (s *CreatefunctionstmtContext) CREATE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCREATE, 0)
}

func (s *CreatefunctionstmtContext) Opt_or_replace() IOpt_or_replaceContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOpt_or_replaceContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOpt_or_replaceContext)
}

func (s *CreatefunctionstmtContext) Func_name() IFunc_nameContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IFunc_nameContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IFunc_nameContext)
}

func (s *CreatefunctionstmtContext) Func_args_with_defaults() IFunc_args_with_defaultsContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IFunc_args_with_defaultsContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IFunc_args_with_defaultsContext)
}

func (s *CreatefunctionstmtContext) Createfunc_opt_list() ICreatefunc_opt_listContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ICreatefunc_opt_listContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ICreatefunc_opt_listContext)
}

func (s *CreatefunctionstmtContext) FUNCTION() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserFUNCTION, 0)
}

func (s *CreatefunctionstmtContext) PROCEDURE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserPROCEDURE, 0)
}

func (s *CreatefunctionstmtContext) RETURNS() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserRETURNS, 0)
}

func (s *CreatefunctionstmtContext) Func_return() IFunc_returnContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IFunc_returnContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IFunc_returnContext)
}

func (s *CreatefunctionstmtContext) TABLE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserTABLE, 0)
}

func (s *CreatefunctionstmtContext) OPEN_PAREN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserOPEN_PAREN, 0)
}

func (s *CreatefunctionstmtContext) Table_func_column_list() ITable_func_column_listContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ITable_func_column_listContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ITable_func_column_listContext)
}

func (s *CreatefunctionstmtContext) CLOSE_PAREN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCLOSE_PAREN, 0)
}

func (s *CreatefunctionstmtContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *CreatefunctionstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *CreatefunctionstmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterCreatefunctionstmt(s)
	}
}

func (s *CreatefunctionstmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitCreatefunctionstmt(s)
	}
}

func (s *CreatefunctionstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitCreatefunctionstmt(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Createfunctionstmt() (localctx ICreatefunctionstmtContext) {
	localctx = NewCreatefunctionstmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 616, PostgreSQLParserRULE_createfunctionstmt)
	var _la int

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(5363)
		p.Match(PostgreSQLParserCREATE)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(5364)
		p.Opt_or_replace()
	}
	{
		p.SetState(5365)
		_la = p.GetTokenStream().LA(1)

		if !(_la == PostgreSQLParserFUNCTION || _la == PostgreSQLParserPROCEDURE) {
			p.GetErrorHandler().RecoverInline(p)
		} else {
			p.GetErrorHandler().ReportMatch(p)
			p.Consume()
		}
	}
	{
		p.SetState(5366)
		p.Func_name()
	}
	{
		p.SetState(5367)
		p.Func_args_with_defaults()
	}
	p.SetState(5377)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 264, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(5368)
			p.Match(PostgreSQLParserRETURNS)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		p.SetState(5375)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}

		switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 263, p.GetParserRuleContext()) {
		case 1:
			{
				p.SetState(5369)
				p.Func_return()
			}

		case 2:
			{
				p.SetState(5370)
				p.Match(PostgreSQLParserTABLE)
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}
			{
				p.SetState(5371)
				p.Match(PostgreSQLParserOPEN_PAREN)
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}
			{
				p.SetState(5372)
				p.Table_func_column_list()
			}
			{
				p.SetState(5373)
				p.Match(PostgreSQLParserCLOSE_PAREN)
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}

		case antlr.ATNInvalidAltNumber:
			goto errorExit
		}

	} else if p.HasError() { // JIM
		goto errorExit
	}
	{
		p.SetState(5379)
		p.Createfunc_opt_list()
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IOpt_or_replaceContext is an interface to support dynamic dispatch.
type IOpt_or_replaceContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	OR() antlr.TerminalNode
	REPLACE() antlr.TerminalNode

	// IsOpt_or_replaceContext differentiates from other interfaces.
	IsOpt_or_replaceContext()
}

type Opt_or_replaceContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyOpt_or_replaceContext() *Opt_or_replaceContext {
	var p = new(Opt_or_replaceContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opt_or_replace
	return p
}

func InitEmptyOpt_or_replaceContext(p *Opt_or_replaceContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opt_or_replace
}

func (*Opt_or_replaceContext) IsOpt_or_replaceContext() {}

func NewOpt_or_replaceContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_or_replaceContext {
	var p = new(Opt_or_replaceContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_opt_or_replace

	return p
}

func (s *Opt_or_replaceContext) GetParser() antlr.Parser { return s.parser }

func (s *Opt_or_replaceContext) OR() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserOR, 0)
}

func (s *Opt_or_replaceContext) REPLACE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserREPLACE, 0)
}

func (s *Opt_or_replaceContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Opt_or_replaceContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Opt_or_replaceContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterOpt_or_replace(s)
	}
}

func (s *Opt_or_replaceContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitOpt_or_replace(s)
	}
}

func (s *Opt_or_replaceContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitOpt_or_replace(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Opt_or_replace() (localctx IOpt_or_replaceContext) {
	localctx = NewOpt_or_replaceContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 618, PostgreSQLParserRULE_opt_or_replace)
	p.SetState(5384)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetTokenStream().LA(1) {
	case PostgreSQLParserOR:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(5381)
			p.Match(PostgreSQLParserOR)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5382)
			p.Match(PostgreSQLParserREPLACE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case PostgreSQLParserAGGREGATE, PostgreSQLParserFUNCTION, PostgreSQLParserLANGUAGE, PostgreSQLParserPROCEDURAL, PostgreSQLParserPROCEDURE, PostgreSQLParserRULE, PostgreSQLParserTRUSTED, PostgreSQLParserTRANSFORM:
		p.EnterOuterAlt(localctx, 2)

	default:
		p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IFunc_argsContext is an interface to support dynamic dispatch.
type IFunc_argsContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	OPEN_PAREN() antlr.TerminalNode
	CLOSE_PAREN() antlr.TerminalNode
	Func_args_list() IFunc_args_listContext

	// IsFunc_argsContext differentiates from other interfaces.
	IsFunc_argsContext()
}

type Func_argsContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyFunc_argsContext() *Func_argsContext {
	var p = new(Func_argsContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_func_args
	return p
}

func InitEmptyFunc_argsContext(p *Func_argsContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_func_args
}

func (*Func_argsContext) IsFunc_argsContext() {}

func NewFunc_argsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Func_argsContext {
	var p = new(Func_argsContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_func_args

	return p
}

func (s *Func_argsContext) GetParser() antlr.Parser { return s.parser }

func (s *Func_argsContext) OPEN_PAREN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserOPEN_PAREN, 0)
}

func (s *Func_argsContext) CLOSE_PAREN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCLOSE_PAREN, 0)
}

func (s *Func_argsContext) Func_args_list() IFunc_args_listContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IFunc_args_listContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IFunc_args_listContext)
}

func (s *Func_argsContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Func_argsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Func_argsContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterFunc_args(s)
	}
}

func (s *Func_argsContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitFunc_args(s)
	}
}

func (s *Func_argsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitFunc_args(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Func_args() (localctx IFunc_argsContext) {
	localctx = NewFunc_argsContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 620, PostgreSQLParserRULE_func_args)
	var _la int

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(5386)
		p.Match(PostgreSQLParserOPEN_PAREN)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	p.SetState(5388)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}
	_la = p.GetTokenStream().LA(1)

	if ((int64((_la-33)) & ^0x3f) == 0 && ((int64(1)<<(_la-33))&576460786949430277) != 0) || ((int64((_la-101)) & ^0x3f) == 0 && ((int64(1)<<(_la-101))&-31) != 0) || ((int64((_la-165)) & ^0x3f) == 0 && ((int64(1)<<(_la-165))&-1) != 0) || ((int64((_la-229)) & ^0x3f) == 0 && ((int64(1)<<(_la-229))&-18874369) != 0) || ((int64((_la-293)) & ^0x3f) == 0 && ((int64(1)<<(_la-293))&-1) != 0) || ((int64((_la-357)) & ^0x3f) == 0 && ((int64(1)<<(_la-357))&-1) != 0) || ((int64((_la-421)) & ^0x3f) == 0 && ((int64(1)<<(_la-421))&-8589934593) != 0) || ((int64((_la-485)) & ^0x3f) == 0 && ((int64(1)<<(_la-485))&-17181179905) != 0) || ((int64((_la-549)) & ^0x3f) == 0 && ((int64(1)<<(_la-549))&-1) != 0) || ((int64((_la-613)) & ^0x3f) == 0 && ((int64(1)<<(_la-613))&844425232121855) != 0) {
		{
			p.SetState(5387)
			p.Func_args_list()
		}

	}
	{
		p.SetState(5390)
		p.Match(PostgreSQLParserCLOSE_PAREN)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IFunc_args_listContext is an interface to support dynamic dispatch.
type IFunc_args_listContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	AllFunc_arg() []IFunc_argContext
	Func_arg(i int) IFunc_argContext
	AllCOMMA() []antlr.TerminalNode
	COMMA(i int) antlr.TerminalNode

	// IsFunc_args_listContext differentiates from other interfaces.
	IsFunc_args_listContext()
}

type Func_args_listContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyFunc_args_listContext() *Func_args_listContext {
	var p = new(Func_args_listContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_func_args_list
	return p
}

func InitEmptyFunc_args_listContext(p *Func_args_listContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_func_args_list
}

func (*Func_args_listContext) IsFunc_args_listContext() {}

func NewFunc_args_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Func_args_listContext {
	var p = new(Func_args_listContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_func_args_list

	return p
}

func (s *Func_args_listContext) GetParser() antlr.Parser { return s.parser }

func (s *Func_args_listContext) AllFunc_arg() []IFunc_argContext {
	children := s.GetChildren()
	len := 0
	for _, ctx := range children {
		if _, ok := ctx.(IFunc_argContext); ok {
			len++
		}
	}

	tst := make([]IFunc_argContext, len)
	i := 0
	for _, ctx := range children {
		if t, ok := ctx.(IFunc_argContext); ok {
			tst[i] = t.(IFunc_argContext)
			i++
		}
	}

	return tst
}

func (s *Func_args_listContext) Func_arg(i int) IFunc_argContext {
	var t antlr.RuleContext
	j := 0
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IFunc_argContext); ok {
			if j == i {
				t = ctx.(antlr.RuleContext)
				break
			}
			j++
		}
	}

	if t == nil {
		return nil
	}

	return t.(IFunc_argContext)
}

func (s *Func_args_listContext) AllCOMMA() []antlr.TerminalNode {
	return s.GetTokens(PostgreSQLParserCOMMA)
}

func (s *Func_args_listContext) COMMA(i int) antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCOMMA, i)
}

func (s *Func_args_listContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Func_args_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Func_args_listContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterFunc_args_list(s)
	}
}

func (s *Func_args_listContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitFunc_args_list(s)
	}
}

func (s *Func_args_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitFunc_args_list(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Func_args_list() (localctx IFunc_args_listContext) {
	localctx = NewFunc_args_listContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 622, PostgreSQLParserRULE_func_args_list)
	var _la int

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(5392)
		p.Func_arg()
	}
	p.SetState(5397)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}
	_la = p.GetTokenStream().LA(1)

	for _la == PostgreSQLParserCOMMA {
		{
			p.SetState(5393)
			p.Match(PostgreSQLParserCOMMA)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5394)
			p.Func_arg()
		}

		p.SetState(5399)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}
		_la = p.GetTokenStream().LA(1)
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IFunction_with_argtypes_listContext is an interface to support dynamic dispatch.
type IFunction_with_argtypes_listContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	AllFunction_with_argtypes() []IFunction_with_argtypesContext
	Function_with_argtypes(i int) IFunction_with_argtypesContext
	AllCOMMA() []antlr.TerminalNode
	COMMA(i int) antlr.TerminalNode

	// IsFunction_with_argtypes_listContext differentiates from other interfaces.
	IsFunction_with_argtypes_listContext()
}

type Function_with_argtypes_listContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyFunction_with_argtypes_listContext() *Function_with_argtypes_listContext {
	var p = new(Function_with_argtypes_listContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_function_with_argtypes_list
	return p
}

func InitEmptyFunction_with_argtypes_listContext(p *Function_with_argtypes_listContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_function_with_argtypes_list
}

func (*Function_with_argtypes_listContext) IsFunction_with_argtypes_listContext() {}

func NewFunction_with_argtypes_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Function_with_argtypes_listContext {
	var p = new(Function_with_argtypes_listContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_function_with_argtypes_list

	return p
}

func (s *Function_with_argtypes_listContext) GetParser() antlr.Parser { return s.parser }

func (s *Function_with_argtypes_listContext) AllFunction_with_argtypes() []IFunction_with_argtypesContext {
	children := s.GetChildren()
	len := 0
	for _, ctx := range children {
		if _, ok := ctx.(IFunction_with_argtypesContext); ok {
			len++
		}
	}

	tst := make([]IFunction_with_argtypesContext, len)
	i := 0
	for _, ctx := range children {
		if t, ok := ctx.(IFunction_with_argtypesContext); ok {
			tst[i] = t.(IFunction_with_argtypesContext)
			i++
		}
	}

	return tst
}

func (s *Function_with_argtypes_listContext) Function_with_argtypes(i int) IFunction_with_argtypesContext {
	var t antlr.RuleContext
	j := 0
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IFunction_with_argtypesContext); ok {
			if j == i {
				t = ctx.(antlr.RuleContext)
				break
			}
			j++
		}
	}

	if t == nil {
		return nil
	}

	return t.(IFunction_with_argtypesContext)
}

func (s *Function_with_argtypes_listContext) AllCOMMA() []antlr.TerminalNode {
	return s.GetTokens(PostgreSQLParserCOMMA)
}

func (s *Function_with_argtypes_listContext) COMMA(i int) antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCOMMA, i)
}

func (s *Function_with_argtypes_listContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Function_with_argtypes_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Function_with_argtypes_listContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterFunction_with_argtypes_list(s)
	}
}

func (s *Function_with_argtypes_listContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitFunction_with_argtypes_list(s)
	}
}

func (s *Function_with_argtypes_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitFunction_with_argtypes_list(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Function_with_argtypes_list() (localctx IFunction_with_argtypes_listContext) {
	localctx = NewFunction_with_argtypes_listContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 624, PostgreSQLParserRULE_function_with_argtypes_list)
	var _la int

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(5400)
		p.Function_with_argtypes()
	}
	p.SetState(5405)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}
	_la = p.GetTokenStream().LA(1)

	for _la == PostgreSQLParserCOMMA {
		{
			p.SetState(5401)
			p.Match(PostgreSQLParserCOMMA)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5402)
			p.Function_with_argtypes()
		}

		p.SetState(5407)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}
		_la = p.GetTokenStream().LA(1)
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IFunction_with_argtypesContext is an interface to support dynamic dispatch.
type IFunction_with_argtypesContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Func_name() IFunc_nameContext
	Func_args() IFunc_argsContext
	Type_func_name_keyword() IType_func_name_keywordContext
	Colid() IColidContext
	Indirection() IIndirectionContext

	// IsFunction_with_argtypesContext differentiates from other interfaces.
	IsFunction_with_argtypesContext()
}

type Function_with_argtypesContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyFunction_with_argtypesContext() *Function_with_argtypesContext {
	var p = new(Function_with_argtypesContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_function_with_argtypes
	return p
}

func InitEmptyFunction_with_argtypesContext(p *Function_with_argtypesContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_function_with_argtypes
}

func (*Function_with_argtypesContext) IsFunction_with_argtypesContext() {}

func NewFunction_with_argtypesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Function_with_argtypesContext {
	var p = new(Function_with_argtypesContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_function_with_argtypes

	return p
}

func (s *Function_with_argtypesContext) GetParser() antlr.Parser { return s.parser }

func (s *Function_with_argtypesContext) Func_name() IFunc_nameContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IFunc_nameContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IFunc_nameContext)
}

func (s *Function_with_argtypesContext) Func_args() IFunc_argsContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IFunc_argsContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IFunc_argsContext)
}

func (s *Function_with_argtypesContext) Type_func_name_keyword() IType_func_name_keywordContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IType_func_name_keywordContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IType_func_name_keywordContext)
}

func (s *Function_with_argtypesContext) Colid() IColidContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IColidContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IColidContext)
}

func (s *Function_with_argtypesContext) Indirection() IIndirectionContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IIndirectionContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IIndirectionContext)
}

func (s *Function_with_argtypesContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Function_with_argtypesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Function_with_argtypesContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterFunction_with_argtypes(s)
	}
}

func (s *Function_with_argtypesContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitFunction_with_argtypes(s)
	}
}

func (s *Function_with_argtypesContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitFunction_with_argtypes(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Function_with_argtypes() (localctx IFunction_with_argtypesContext) {
	localctx = NewFunction_with_argtypesContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 626, PostgreSQLParserRULE_function_with_argtypes)
	var _la int

	p.SetState(5416)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 270, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(5408)
			p.Func_name()
		}
		{
			p.SetState(5409)
			p.Func_args()
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(5411)
			p.Type_func_name_keyword()
		}

	case 3:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(5412)
			p.Colid()
		}
		p.SetState(5414)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}
		_la = p.GetTokenStream().LA(1)

		if _la == PostgreSQLParserOPEN_BRACKET || _la == PostgreSQLParserDOT {
			{
				p.SetState(5413)
				p.Indirection()
			}

		}

	case antlr.ATNInvalidAltNumber:
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IFunc_args_with_defaultsContext is an interface to support dynamic dispatch.
type IFunc_args_with_defaultsContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	OPEN_PAREN() antlr.TerminalNode
	CLOSE_PAREN() antlr.TerminalNode
	Func_args_with_defaults_list() IFunc_args_with_defaults_listContext

	// IsFunc_args_with_defaultsContext differentiates from other interfaces.
	IsFunc_args_with_defaultsContext()
}

type Func_args_with_defaultsContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyFunc_args_with_defaultsContext() *Func_args_with_defaultsContext {
	var p = new(Func_args_with_defaultsContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_func_args_with_defaults
	return p
}

func InitEmptyFunc_args_with_defaultsContext(p *Func_args_with_defaultsContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_func_args_with_defaults
}

func (*Func_args_with_defaultsContext) IsFunc_args_with_defaultsContext() {}

func NewFunc_args_with_defaultsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Func_args_with_defaultsContext {
	var p = new(Func_args_with_defaultsContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_func_args_with_defaults

	return p
}

func (s *Func_args_with_defaultsContext) GetParser() antlr.Parser { return s.parser }

func (s *Func_args_with_defaultsContext) OPEN_PAREN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserOPEN_PAREN, 0)
}

func (s *Func_args_with_defaultsContext) CLOSE_PAREN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCLOSE_PAREN, 0)
}

func (s *Func_args_with_defaultsContext) Func_args_with_defaults_list() IFunc_args_with_defaults_listContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IFunc_args_with_defaults_listContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IFunc_args_with_defaults_listContext)
}

func (s *Func_args_with_defaultsContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Func_args_with_defaultsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Func_args_with_defaultsContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterFunc_args_with_defaults(s)
	}
}

func (s *Func_args_with_defaultsContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitFunc_args_with_defaults(s)
	}
}

func (s *Func_args_with_defaultsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitFunc_args_with_defaults(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Func_args_with_defaults() (localctx IFunc_args_with_defaultsContext) {
	localctx = NewFunc_args_with_defaultsContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 628, PostgreSQLParserRULE_func_args_with_defaults)
	var _la int

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(5418)
		p.Match(PostgreSQLParserOPEN_PAREN)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	p.SetState(5420)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}
	_la = p.GetTokenStream().LA(1)

	if ((int64((_la-33)) & ^0x3f) == 0 && ((int64(1)<<(_la-33))&576460786949430277) != 0) || ((int64((_la-101)) & ^0x3f) == 0 && ((int64(1)<<(_la-101))&-31) != 0) || ((int64((_la-165)) & ^0x3f) == 0 && ((int64(1)<<(_la-165))&-1) != 0) || ((int64((_la-229)) & ^0x3f) == 0 && ((int64(1)<<(_la-229))&-18874369) != 0) || ((int64((_la-293)) & ^0x3f) == 0 && ((int64(1)<<(_la-293))&-1) != 0) || ((int64((_la-357)) & ^0x3f) == 0 && ((int64(1)<<(_la-357))&-1) != 0) || ((int64((_la-421)) & ^0x3f) == 0 && ((int64(1)<<(_la-421))&-8589934593) != 0) || ((int64((_la-485)) & ^0x3f) == 0 && ((int64(1)<<(_la-485))&-17181179905) != 0) || ((int64((_la-549)) & ^0x3f) == 0 && ((int64(1)<<(_la-549))&-1) != 0) || ((int64((_la-613)) & ^0x3f) == 0 && ((int64(1)<<(_la-613))&844425232121855) != 0) {
		{
			p.SetState(5419)
			p.Func_args_with_defaults_list()
		}

	}
	{
		p.SetState(5422)
		p.Match(PostgreSQLParserCLOSE_PAREN)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IFunc_args_with_defaults_listContext is an interface to support dynamic dispatch.
type IFunc_args_with_defaults_listContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	AllFunc_arg_with_default() []IFunc_arg_with_defaultContext
	Func_arg_with_default(i int) IFunc_arg_with_defaultContext
	AllCOMMA() []antlr.TerminalNode
	COMMA(i int) antlr.TerminalNode

	// IsFunc_args_with_defaults_listContext differentiates from other interfaces.
	IsFunc_args_with_defaults_listContext()
}

type Func_args_with_defaults_listContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyFunc_args_with_defaults_listContext() *Func_args_with_defaults_listContext {
	var p = new(Func_args_with_defaults_listContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_func_args_with_defaults_list
	return p
}

func InitEmptyFunc_args_with_defaults_listContext(p *Func_args_with_defaults_listContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_func_args_with_defaults_list
}

func (*Func_args_with_defaults_listContext) IsFunc_args_with_defaults_listContext() {}

func NewFunc_args_with_defaults_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Func_args_with_defaults_listContext {
	var p = new(Func_args_with_defaults_listContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_func_args_with_defaults_list

	return p
}

func (s *Func_args_with_defaults_listContext) GetParser() antlr.Parser { return s.parser }

func (s *Func_args_with_defaults_listContext) AllFunc_arg_with_default() []IFunc_arg_with_defaultContext {
	children := s.GetChildren()
	len := 0
	for _, ctx := range children {
		if _, ok := ctx.(IFunc_arg_with_defaultContext); ok {
			len++
		}
	}

	tst := make([]IFunc_arg_with_defaultContext, len)
	i := 0
	for _, ctx := range children {
		if t, ok := ctx.(IFunc_arg_with_defaultContext); ok {
			tst[i] = t.(IFunc_arg_with_defaultContext)
			i++
		}
	}

	return tst
}

func (s *Func_args_with_defaults_listContext) Func_arg_with_default(i int) IFunc_arg_with_defaultContext {
	var t antlr.RuleContext
	j := 0
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IFunc_arg_with_defaultContext); ok {
			if j == i {
				t = ctx.(antlr.RuleContext)
				break
			}
			j++
		}
	}

	if t == nil {
		return nil
	}

	return t.(IFunc_arg_with_defaultContext)
}

func (s *Func_args_with_defaults_listContext) AllCOMMA() []antlr.TerminalNode {
	return s.GetTokens(PostgreSQLParserCOMMA)
}

func (s *Func_args_with_defaults_listContext) COMMA(i int) antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCOMMA, i)
}

func (s *Func_args_with_defaults_listContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Func_args_with_defaults_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Func_args_with_defaults_listContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterFunc_args_with_defaults_list(s)
	}
}

func (s *Func_args_with_defaults_listContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitFunc_args_with_defaults_list(s)
	}
}

func (s *Func_args_with_defaults_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitFunc_args_with_defaults_list(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Func_args_with_defaults_list() (localctx IFunc_args_with_defaults_listContext) {
	localctx = NewFunc_args_with_defaults_listContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 630, PostgreSQLParserRULE_func_args_with_defaults_list)
	var _la int

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(5424)
		p.Func_arg_with_default()
	}
	p.SetState(5429)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}
	_la = p.GetTokenStream().LA(1)

	for _la == PostgreSQLParserCOMMA {
		{
			p.SetState(5425)
			p.Match(PostgreSQLParserCOMMA)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5426)
			p.Func_arg_with_default()
		}

		p.SetState(5431)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}
		_la = p.GetTokenStream().LA(1)
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IFunc_argContext is an interface to support dynamic dispatch.
type IFunc_argContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Arg_class() IArg_classContext
	Func_type() IFunc_typeContext
	Param_name() IParam_nameContext

	// IsFunc_argContext differentiates from other interfaces.
	IsFunc_argContext()
}

type Func_argContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyFunc_argContext() *Func_argContext {
	var p = new(Func_argContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_func_arg
	return p
}

func InitEmptyFunc_argContext(p *Func_argContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_func_arg
}

func (*Func_argContext) IsFunc_argContext() {}

func NewFunc_argContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Func_argContext {
	var p = new(Func_argContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_func_arg

	return p
}

func (s *Func_argContext) GetParser() antlr.Parser { return s.parser }

func (s *Func_argContext) Arg_class() IArg_classContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IArg_classContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IArg_classContext)
}

func (s *Func_argContext) Func_type() IFunc_typeContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IFunc_typeContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IFunc_typeContext)
}

func (s *Func_argContext) Param_name() IParam_nameContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IParam_nameContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IParam_nameContext)
}

func (s *Func_argContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Func_argContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Func_argContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterFunc_arg(s)
	}
}

func (s *Func_argContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitFunc_arg(s)
	}
}

func (s *Func_argContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitFunc_arg(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Func_arg() (localctx IFunc_argContext) {
	localctx = NewFunc_argContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 632, PostgreSQLParserRULE_func_arg)
	p.SetState(5445)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 275, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(5432)
			p.Arg_class()
		}
		p.SetState(5434)
		p.GetErrorHandler().Sync(p)

		if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 273, p.GetParserRuleContext()) == 1 {
			{
				p.SetState(5433)
				p.Param_name()
			}

		} else if p.HasError() { // JIM
			goto errorExit
		}
		{
			p.SetState(5436)
			p.Func_type()
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(5438)
			p.Param_name()
		}
		p.SetState(5440)
		p.GetErrorHandler().Sync(p)

		if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 274, p.GetParserRuleContext()) == 1 {
			{
				p.SetState(5439)
				p.Arg_class()
			}

		} else if p.HasError() { // JIM
			goto errorExit
		}
		{
			p.SetState(5442)
			p.Func_type()
		}

	case 3:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(5444)
			p.Func_type()
		}

	case antlr.ATNInvalidAltNumber:
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IArg_classContext is an interface to support dynamic dispatch.
type IArg_classContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	IN_P() antlr.TerminalNode
	OUT_P() antlr.TerminalNode
	INOUT() antlr.TerminalNode
	VARIADIC() antlr.TerminalNode

	// IsArg_classContext differentiates from other interfaces.
	IsArg_classContext()
}

type Arg_classContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyArg_classContext() *Arg_classContext {
	var p = new(Arg_classContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_arg_class
	return p
}

func InitEmptyArg_classContext(p *Arg_classContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_arg_class
}

func (*Arg_classContext) IsArg_classContext() {}

func NewArg_classContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Arg_classContext {
	var p = new(Arg_classContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_arg_class

	return p
}

func (s *Arg_classContext) GetParser() antlr.Parser { return s.parser }

func (s *Arg_classContext) IN_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserIN_P, 0)
}

func (s *Arg_classContext) OUT_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserOUT_P, 0)
}

func (s *Arg_classContext) INOUT() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserINOUT, 0)
}

func (s *Arg_classContext) VARIADIC() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserVARIADIC, 0)
}

func (s *Arg_classContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Arg_classContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Arg_classContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterArg_class(s)
	}
}

func (s *Arg_classContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitArg_class(s)
	}
}

func (s *Arg_classContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitArg_class(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Arg_class() (localctx IArg_classContext) {
	localctx = NewArg_classContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 634, PostgreSQLParserRULE_arg_class)
	p.SetState(5454)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetTokenStream().LA(1) {
	case PostgreSQLParserIN_P:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(5447)
			p.Match(PostgreSQLParserIN_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		p.SetState(5449)
		p.GetErrorHandler().Sync(p)

		if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 276, p.GetParserRuleContext()) == 1 {
			{
				p.SetState(5448)
				p.Match(PostgreSQLParserOUT_P)
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}

		} else if p.HasError() { // JIM
			goto errorExit
		}

	case PostgreSQLParserOUT_P:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(5451)
			p.Match(PostgreSQLParserOUT_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case PostgreSQLParserINOUT:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(5452)
			p.Match(PostgreSQLParserINOUT)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case PostgreSQLParserVARIADIC:
		p.EnterOuterAlt(localctx, 4)
		{
			p.SetState(5453)
			p.Match(PostgreSQLParserVARIADIC)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	default:
		p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IParam_nameContext is an interface to support dynamic dispatch.
type IParam_nameContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Type_function_name() IType_function_nameContext
	Builtin_function_name() IBuiltin_function_nameContext
	LEFT() antlr.TerminalNode
	RIGHT() antlr.TerminalNode

	// IsParam_nameContext differentiates from other interfaces.
	IsParam_nameContext()
}

type Param_nameContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyParam_nameContext() *Param_nameContext {
	var p = new(Param_nameContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_param_name
	return p
}

func InitEmptyParam_nameContext(p *Param_nameContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_param_name
}

func (*Param_nameContext) IsParam_nameContext() {}

func NewParam_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Param_nameContext {
	var p = new(Param_nameContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_param_name

	return p
}

func (s *Param_nameContext) GetParser() antlr.Parser { return s.parser }

func (s *Param_nameContext) Type_function_name() IType_function_nameContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IType_function_nameContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IType_function_nameContext)
}

func (s *Param_nameContext) Builtin_function_name() IBuiltin_function_nameContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IBuiltin_function_nameContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IBuiltin_function_nameContext)
}

func (s *Param_nameContext) LEFT() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserLEFT, 0)
}

func (s *Param_nameContext) RIGHT() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserRIGHT, 0)
}

func (s *Param_nameContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Param_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Param_nameContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterParam_name(s)
	}
}

func (s *Param_nameContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitParam_name(s)
	}
}

func (s *Param_nameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitParam_name(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Param_name() (localctx IParam_nameContext) {
	localctx = NewParam_nameContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 636, PostgreSQLParserRULE_param_name)
	p.SetState(5460)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetTokenStream().LA(1) {
	case PostgreSQLParserAND, PostgreSQLParserARRAY, PostgreSQLParserCOLLATE, PostgreSQLParserCOLUMN, PostgreSQLParserCONSTRAINT, PostgreSQLParserDEFAULT, PostgreSQLParserDO, PostgreSQLParserFETCH, PostgreSQLParserTABLE, PostgreSQLParserAUTHORIZATION, PostgreSQLParserBINARY, PostgreSQLParserCOLLATION, PostgreSQLParserCONCURRENTLY, PostgreSQLParserCROSS, PostgreSQLParserCURRENT_SCHEMA, PostgreSQLParserFREEZE, PostgreSQLParserFULL, PostgreSQLParserILIKE, PostgreSQLParserINNER_P, PostgreSQLParserIS, PostgreSQLParserISNULL, PostgreSQLParserJOIN, PostgreSQLParserLIKE, PostgreSQLParserNATURAL, PostgreSQLParserNOTNULL, PostgreSQLParserOUTER_P, PostgreSQLParserOVER, PostgreSQLParserOVERLAPS, PostgreSQLParserSIMILAR, PostgreSQLParserVERBOSE, PostgreSQLParserABORT_P, PostgreSQLParserABSOLUTE_P, PostgreSQLParserACCESS, PostgreSQLParserACTION, PostgreSQLParserADD_P, PostgreSQLParserADMIN, PostgreSQLParserAFTER, PostgreSQLParserAGGREGATE, PostgreSQLParserALSO, PostgreSQLParserALTER, PostgreSQLParserALWAYS, PostgreSQLParserASSERTION, PostgreSQLParserASSIGNMENT, PostgreSQLParserAT, PostgreSQLParserATTRIBUTE, PostgreSQLParserBACKWARD, PostgreSQLParserBEFORE, PostgreSQLParserBEGIN_P, PostgreSQLParserBY, PostgreSQLParserCACHE, PostgreSQLParserCALLED, PostgreSQLParserCASCADE, PostgreSQLParserCASCADED, PostgreSQLParserCATALOG, PostgreSQLParserCHAIN, PostgreSQLParserCHARACTERISTICS, PostgreSQLParserCHECKPOINT, PostgreSQLParserCLASS, PostgreSQLParserCLOSE, PostgreSQLParserCLUSTER, PostgreSQLParserCOMMENT, PostgreSQLParserCOMMENTS, PostgreSQLParserCOMMIT, PostgreSQLParserCOMMITTED, PostgreSQLParserCONFIGURATION, PostgreSQLParserCONNECTION, PostgreSQLParserCONSTRAINTS, PostgreSQLParserCONTENT_P, PostgreSQLParserCONTINUE_P, PostgreSQLParserCONVERSION_P, PostgreSQLParserCOPY, PostgreSQLParserCOST, PostgreSQLParserCSV, PostgreSQLParserCURSOR, PostgreSQLParserCYCLE, PostgreSQLParserDATA_P, PostgreSQLParserDATABASE, PostgreSQLParserDAY_P, PostgreSQLParserDEALLOCATE, PostgreSQLParserDECLARE, PostgreSQLParserDEFAULTS, PostgreSQLParserDEFERRED, PostgreSQLParserDEFINER, PostgreSQLParserDELETE_P, PostgreSQLParserDELIMITER, PostgreSQLParserDELIMITERS, PostgreSQLParserDICTIONARY, PostgreSQLParserDISABLE_P, PostgreSQLParserDISCARD, PostgreSQLParserDOCUMENT_P, PostgreSQLParserDOMAIN_P, PostgreSQLParserDOUBLE_P, PostgreSQLParserDROP, PostgreSQLParserEACH, PostgreSQLParserENABLE_P, PostgreSQLParserENCODING, PostgreSQLParserENCRYPTED, PostgreSQLParserENUM_P, PostgreSQLParserESCAPE, PostgreSQLParserEVENT, PostgreSQLParserEXCLUDE, PostgreSQLParserEXCLUDING, PostgreSQLParserEXCLUSIVE, PostgreSQLParserEXECUTE, PostgreSQLParserEXPLAIN, PostgreSQLParserEXTENSION, PostgreSQLParserEXTERNAL, PostgreSQLParserFAMILY, PostgreSQLParserFIRST_P, PostgreSQLParserFOLLOWING, PostgreSQLParserFORCE, PostgreSQLParserFORWARD, PostgreSQLParserFUNCTION, PostgreSQLParserFUNCTIONS, PostgreSQLParserGLOBAL, PostgreSQLParserGRANTED, PostgreSQLParserHANDLER, PostgreSQLParserHEADER_P, PostgreSQLParserHOLD, PostgreSQLParserHOUR_P, PostgreSQLParserIDENTITY_P, PostgreSQLParserIF_P, PostgreSQLParserIMMEDIATE, PostgreSQLParserIMMUTABLE, PostgreSQLParserIMPLICIT_P, PostgreSQLParserINCLUDING, PostgreSQLParserINCREMENT, PostgreSQLParserINDEX, PostgreSQLParserINDEXES, PostgreSQLParserINHERIT, PostgreSQLParserINHERITS, PostgreSQLParserINLINE_P, PostgreSQLParserINSENSITIVE, PostgreSQLParserINSERT, PostgreSQLParserINSTEAD, PostgreSQLParserINVOKER, PostgreSQLParserISOLATION, PostgreSQLParserKEY, PostgreSQLParserLABEL, PostgreSQLParserLANGUAGE, PostgreSQLParserLARGE_P, PostgreSQLParserLAST_P, PostgreSQLParserLEAKPROOF, PostgreSQLParserLEVEL, PostgreSQLParserLISTEN, PostgreSQLParserLOAD, PostgreSQLParserLOCAL, PostgreSQLParserLOCATION, PostgreSQLParserLOCK_P, PostgreSQLParserMAPPING, PostgreSQLParserMATCH, PostgreSQLParserMATERIALIZED, PostgreSQLParserMAXVALUE, PostgreSQLParserMINUTE_P, PostgreSQLParserMINVALUE, PostgreSQLParserMODE, PostgreSQLParserMONTH_P, PostgreSQLParserMOVE, PostgreSQLParserNAME_P, PostgreSQLParserNAMES, PostgreSQLParserNEXT, PostgreSQLParserNO, PostgreSQLParserNOTHING, PostgreSQLParserNOTIFY, PostgreSQLParserNOWAIT, PostgreSQLParserNULLS_P, PostgreSQLParserOBJECT_P, PostgreSQLParserOF, PostgreSQLParserOFF, PostgreSQLParserOIDS, PostgreSQLParserOPERATOR, PostgreSQLParserOPTION, PostgreSQLParserOPTIONS, PostgreSQLParserOWNED, PostgreSQLParserOWNER, PostgreSQLParserPARSER, PostgreSQLParserPARTIAL, PostgreSQLParserPARTITION, PostgreSQLParserPASSING, PostgreSQLParserPASSWORD, PostgreSQLParserPLANS, PostgreSQLParserPRECEDING, PostgreSQLParserPREPARE, PostgreSQLParserPREPARED, PostgreSQLParserPRESERVE, PostgreSQLParserPRIOR, PostgreSQLParserPRIVILEGES, PostgreSQLParserPROCEDURAL, PostgreSQLParserPROCEDURE, PostgreSQLParserPROGRAM, PostgreSQLParserQUOTE, PostgreSQLParserRANGE, PostgreSQLParserREAD, PostgreSQLParserREASSIGN, PostgreSQLParserRECHECK, PostgreSQLParserRECURSIVE, PostgreSQLParserREF, PostgreSQLParserREFRESH, PostgreSQLParserREINDEX, PostgreSQLParserRELATIVE_P, PostgreSQLParserRELEASE, PostgreSQLParserRENAME, PostgreSQLParserREPEATABLE, PostgreSQLParserREPLICA, PostgreSQLParserRESET, PostgreSQLParserRESTART, PostgreSQLParserRESTRICT, PostgreSQLParserRETURNS, PostgreSQLParserREVOKE, PostgreSQLParserROLE, PostgreSQLParserROLLBACK, PostgreSQLParserROWS, PostgreSQLParserRULE, PostgreSQLParserSAVEPOINT, PostgreSQLParserSCHEMA, PostgreSQLParserSCROLL, PostgreSQLParserSEARCH, PostgreSQLParserSECOND_P, PostgreSQLParserSECURITY, PostgreSQLParserSEQUENCE, PostgreSQLParserSEQUENCES, PostgreSQLParserSERIALIZABLE, PostgreSQLParserSERVER, PostgreSQLParserSESSION, PostgreSQLParserSET, PostgreSQLParserSHARE, PostgreSQLParserSHOW, PostgreSQLParserSIMPLE, PostgreSQLParserSNAPSHOT, PostgreSQLParserSTABLE, PostgreSQLParserSTANDALONE_P, PostgreSQLParserSTART, PostgreSQLParserSTATEMENT, PostgreSQLParserSTATISTICS, PostgreSQLParserSTDIN, PostgreSQLParserSTDOUT, PostgreSQLParserSTORAGE, PostgreSQLParserSTRICT_P, PostgreSQLParserSTRIP_P, PostgreSQLParserSYSID, PostgreSQLParserSYSTEM_P, PostgreSQLParserTABLES, PostgreSQLParserTABLESPACE, PostgreSQLParserTEMP, PostgreSQLParserTEMPLATE, PostgreSQLParserTEMPORARY, PostgreSQLParserTEXT_P, PostgreSQLParserTRANSACTION, PostgreSQLParserTRIGGER, PostgreSQLParserTRUNCATE, PostgreSQLParserTRUSTED, PostgreSQLParserTYPE_P, PostgreSQLParserTYPES_P, PostgreSQLParserUNBOUNDED, PostgreSQLParserUNCOMMITTED, PostgreSQLParserUNENCRYPTED, PostgreSQLParserUNKNOWN, PostgreSQLParserUNLISTEN, PostgreSQLParserUNLOGGED, PostgreSQLParserUNTIL, PostgreSQLParserUPDATE, PostgreSQLParserVACUUM, PostgreSQLParserVALID, PostgreSQLParserVALIDATE, PostgreSQLParserVALIDATOR, PostgreSQLParserVARYING, PostgreSQLParserVERSION_P, PostgreSQLParserVIEW, PostgreSQLParserVOLATILE, PostgreSQLParserWHITESPACE_P, PostgreSQLParserWITHOUT, PostgreSQLParserWORK, PostgreSQLParserWRAPPER, PostgreSQLParserWRITE, PostgreSQLParserXML_P, PostgreSQLParserYEAR_P, PostgreSQLParserYES_P, PostgreSQLParserZONE, PostgreSQLParserCALL, PostgreSQLParserCURRENT_P, PostgreSQLParserATTACH, PostgreSQLParserDETACH, PostgreSQLParserEXPRESSION, PostgreSQLParserGENERATED, PostgreSQLParserLOGGED, PostgreSQLParserSTORED, PostgreSQLParserINCLUDE, PostgreSQLParserROUTINE, PostgreSQLParserTRANSFORM, PostgreSQLParserIMPORT_P, PostgreSQLParserPOLICY, PostgreSQLParserMETHOD, PostgreSQLParserREFERENCING, PostgreSQLParserNEW, PostgreSQLParserOLD, PostgreSQLParserVALUE_P, PostgreSQLParserSUBSCRIPTION, PostgreSQLParserPUBLICATION, PostgreSQLParserROUTINES, PostgreSQLParserSCHEMAS, PostgreSQLParserPROCEDURES, PostgreSQLParserINPUT_P, PostgreSQLParserSUPPORT, PostgreSQLParserPARALLEL, PostgreSQLParserSQL_P, PostgreSQLParserDEPENDS, PostgreSQLParserOVERRIDING, PostgreSQLParserCONFLICT, PostgreSQLParserSKIP_P, PostgreSQLParserLOCKED, PostgreSQLParserTIES, PostgreSQLParserROLLUP, PostgreSQLParserCUBE, PostgreSQLParserSETS, PostgreSQLParserTABLESAMPLE, PostgreSQLParserORDINALITY, PostgreSQLParserCOLUMNS, PostgreSQLParserROWTYPE, PostgreSQLParserNORMALIZED, PostgreSQLParserWITHIN, PostgreSQLParserFILTER, PostgreSQLParserGROUPS, PostgreSQLParserOTHERS, PostgreSQLParserNFC, PostgreSQLParserNFD, PostgreSQLParserNFKC, PostgreSQLParserNFKD, PostgreSQLParserUESCAPE, PostgreSQLParserVIEWS, PostgreSQLParserDUMP, PostgreSQLParserPRINT_STRICT_PARAMS, PostgreSQLParserVARIABLE_CONFLICT, PostgreSQLParserERROR, PostgreSQLParserUSE_VARIABLE, PostgreSQLParserUSE_COLUMN, PostgreSQLParserALIAS, PostgreSQLParserCONSTANT, PostgreSQLParserPERFORM, PostgreSQLParserGET, PostgreSQLParserDIAGNOSTICS, PostgreSQLParserSTACKED, PostgreSQLParserELSIF, PostgreSQLParserSLICE, PostgreSQLParserEXIT, PostgreSQLParserRETURN, PostgreSQLParserQUERY, PostgreSQLParserRAISE, PostgreSQLParserSQLSTATE, PostgreSQLParserDEBUG, PostgreSQLParserINFO, PostgreSQLParserNOTICE, PostgreSQLParserWARNING, PostgreSQLParserEXCEPTION, PostgreSQLParserASSERT, PostgreSQLParserOPEN, PostgreSQLParserIdentifier, PostgreSQLParserQuotedIdentifier, PostgreSQLParserUnicodeQuotedIdentifier, PostgreSQLParserPLSQLVARIABLENAME, PostgreSQLParserPLSQLIDENTIFIER:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(5456)
			p.Type_function_name()
		}

	case PostgreSQLParserREPLACE, PostgreSQLParserXMLCOMMENT, PostgreSQLParserXMLAGG, PostgreSQLParserXML_IS_WELL_FORMED, PostgreSQLParserXML_IS_WELL_FORMED_DOCUMENT, PostgreSQLParserXML_IS_WELL_FORMED_CONTENT, PostgreSQLParserXPATH, PostgreSQLParserXPATH_EXISTS, PostgreSQLParserREVERSE, PostgreSQLParserLOG, PostgreSQLParserABS, PostgreSQLParserCBRT, PostgreSQLParserCEIL, PostgreSQLParserCEILING, PostgreSQLParserDEGREES, PostgreSQLParserDIV, PostgreSQLParserEXP, PostgreSQLParserFACTORIAL, PostgreSQLParserFLOOR, PostgreSQLParserGCD, PostgreSQLParserLCM, PostgreSQLParserLN, PostgreSQLParserLOG10, PostgreSQLParserMIN_SCALE, PostgreSQLParserMOD, PostgreSQLParserPI, PostgreSQLParserPOWER, PostgreSQLParserRADIANS, PostgreSQLParserROUND, PostgreSQLParserSCALE, PostgreSQLParserSIGN, PostgreSQLParserSQRT, PostgreSQLParserTRIM_SCALE, PostgreSQLParserTRUNC, PostgreSQLParserWIDTH_BUCKET, PostgreSQLParserRANDOM, PostgreSQLParserSETSEED, PostgreSQLParserACOS, PostgreSQLParserACOSD, PostgreSQLParserASIN, PostgreSQLParserASIND, PostgreSQLParserATAN, PostgreSQLParserATAND, PostgreSQLParserATAN2, PostgreSQLParserATAN2D, PostgreSQLParserCOS, PostgreSQLParserCOSD, PostgreSQLParserCOT, PostgreSQLParserCOTD, PostgreSQLParserSIN, PostgreSQLParserSIND, PostgreSQLParserTAN, PostgreSQLParserTAND, PostgreSQLParserSINH, PostgreSQLParserCOSH, PostgreSQLParserTANH, PostgreSQLParserASINH, PostgreSQLParserACOSH, PostgreSQLParserATANH, PostgreSQLParserBIT_LENGTH, PostgreSQLParserCHAR_LENGTH, PostgreSQLParserCHARACTER_LENGTH, PostgreSQLParserLOWER, PostgreSQLParserOCTET_LENGTH, PostgreSQLParserUPPER, PostgreSQLParserASCII, PostgreSQLParserBTRIM, PostgreSQLParserCHR, PostgreSQLParserCONCAT, PostgreSQLParserCONCAT_WS, PostgreSQLParserFORMAT, PostgreSQLParserINITCAP, PostgreSQLParserLENGTH, PostgreSQLParserLPAD, PostgreSQLParserLTRIM, PostgreSQLParserMD5, PostgreSQLParserPARSE_IDENT, PostgreSQLParserPG_CLIENT_ENCODING, PostgreSQLParserQUOTE_IDENT, PostgreSQLParserQUOTE_LITERAL, PostgreSQLParserQUOTE_NULLABLE, PostgreSQLParserREGEXP_COUNT, PostgreSQLParserREGEXP_INSTR, PostgreSQLParserREGEXP_LIKE, PostgreSQLParserREGEXP_MATCH, PostgreSQLParserREGEXP_MATCHES, PostgreSQLParserREGEXP_REPLACE, PostgreSQLParserREGEXP_SPLIT_TO_ARRAY, PostgreSQLParserREGEXP_SPLIT_TO_TABLE, PostgreSQLParserREGEXP_SUBSTR, PostgreSQLParserREPEAT, PostgreSQLParserRPAD, PostgreSQLParserRTRIM, PostgreSQLParserSPLIT_PART, PostgreSQLParserSTARTS_WITH, PostgreSQLParserSTRING_TO_ARRAY, PostgreSQLParserSTRING_TO_TABLE, PostgreSQLParserSTRPOS, PostgreSQLParserSUBSTR, PostgreSQLParserTO_ASCII, PostgreSQLParserTO_HEX, PostgreSQLParserTRANSLATE, PostgreSQLParserUNISTR, PostgreSQLParserAGE, PostgreSQLParserCLOCK_TIMESTAMP, PostgreSQLParserDATE_BIN, PostgreSQLParserDATE_PART, PostgreSQLParserDATE_TRUNC, PostgreSQLParserISFINITE, PostgreSQLParserJUSTIFY_DAYS, PostgreSQLParserJUSTIFY_HOURS, PostgreSQLParserJUSTIFY_INTERVAL, PostgreSQLParserMAKE_DATE, PostgreSQLParserMAKE_INTERVAL, PostgreSQLParserMAKE_TIME, PostgreSQLParserMAKE_TIMESTAMP, PostgreSQLParserMAKE_TIMESTAMPTZ, PostgreSQLParserNOW, PostgreSQLParserSTATEMENT_TIMESTAMP, PostgreSQLParserTIMEOFDAY, PostgreSQLParserTRANSACTION_TIMESTAMP, PostgreSQLParserTO_TIMESTAMP, PostgreSQLParserTO_CHAR, PostgreSQLParserTO_DATE, PostgreSQLParserTO_NUMBER:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(5457)
			p.Builtin_function_name()
		}

	case PostgreSQLParserLEFT:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(5458)
			p.Match(PostgreSQLParserLEFT)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case PostgreSQLParserRIGHT:
		p.EnterOuterAlt(localctx, 4)
		{
			p.SetState(5459)
			p.Match(PostgreSQLParserRIGHT)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	default:
		p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IFunc_returnContext is an interface to support dynamic dispatch.
type IFunc_returnContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Func_type() IFunc_typeContext

	// IsFunc_returnContext differentiates from other interfaces.
	IsFunc_returnContext()
}

type Func_returnContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyFunc_returnContext() *Func_returnContext {
	var p = new(Func_returnContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_func_return
	return p
}

func InitEmptyFunc_returnContext(p *Func_returnContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_func_return
}

func (*Func_returnContext) IsFunc_returnContext() {}

func NewFunc_returnContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Func_returnContext {
	var p = new(Func_returnContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_func_return

	return p
}

func (s *Func_returnContext) GetParser() antlr.Parser { return s.parser }

func (s *Func_returnContext) Func_type() IFunc_typeContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IFunc_typeContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IFunc_typeContext)
}

func (s *Func_returnContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Func_returnContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Func_returnContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterFunc_return(s)
	}
}

func (s *Func_returnContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitFunc_return(s)
	}
}

func (s *Func_returnContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitFunc_return(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Func_return() (localctx IFunc_returnContext) {
	localctx = NewFunc_returnContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 638, PostgreSQLParserRULE_func_return)
	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(5462)
		p.Func_type()
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IFunc_typeContext is an interface to support dynamic dispatch.
type IFunc_typeContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Typename() ITypenameContext
	Attrs() IAttrsContext
	PERCENT() antlr.TerminalNode
	TYPE_P() antlr.TerminalNode
	Builtin_function_name() IBuiltin_function_nameContext
	Type_function_name() IType_function_nameContext
	LEFT() antlr.TerminalNode
	RIGHT() antlr.TerminalNode
	SETOF() antlr.TerminalNode

	// IsFunc_typeContext differentiates from other interfaces.
	IsFunc_typeContext()
}

type Func_typeContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyFunc_typeContext() *Func_typeContext {
	var p = new(Func_typeContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_func_type
	return p
}

func InitEmptyFunc_typeContext(p *Func_typeContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_func_type
}

func (*Func_typeContext) IsFunc_typeContext() {}

func NewFunc_typeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Func_typeContext {
	var p = new(Func_typeContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_func_type

	return p
}

func (s *Func_typeContext) GetParser() antlr.Parser { return s.parser }

func (s *Func_typeContext) Typename() ITypenameContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ITypenameContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ITypenameContext)
}

func (s *Func_typeContext) Attrs() IAttrsContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IAttrsContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IAttrsContext)
}

func (s *Func_typeContext) PERCENT() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserPERCENT, 0)
}

func (s *Func_typeContext) TYPE_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserTYPE_P, 0)
}

func (s *Func_typeContext) Builtin_function_name() IBuiltin_function_nameContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IBuiltin_function_nameContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IBuiltin_function_nameContext)
}

func (s *Func_typeContext) Type_function_name() IType_function_nameContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IType_function_nameContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IType_function_nameContext)
}

func (s *Func_typeContext) LEFT() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserLEFT, 0)
}

func (s *Func_typeContext) RIGHT() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserRIGHT, 0)
}

func (s *Func_typeContext) SETOF() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserSETOF, 0)
}

func (s *Func_typeContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Func_typeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Func_typeContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterFunc_type(s)
	}
}

func (s *Func_typeContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitFunc_type(s)
	}
}

func (s *Func_typeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitFunc_type(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Func_type() (localctx IFunc_typeContext) {
	localctx = NewFunc_typeContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 640, PostgreSQLParserRULE_func_type)
	var _la int

	p.SetState(5478)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 281, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(5464)
			p.Typename()
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		p.SetState(5466)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}
		_la = p.GetTokenStream().LA(1)

		if _la == PostgreSQLParserSETOF {
			{
				p.SetState(5465)
				p.Match(PostgreSQLParserSETOF)
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}

		}
		p.SetState(5472)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}

		switch p.GetTokenStream().LA(1) {
		case PostgreSQLParserREPLACE, PostgreSQLParserXMLCOMMENT, PostgreSQLParserXMLAGG, PostgreSQLParserXML_IS_WELL_FORMED, PostgreSQLParserXML_IS_WELL_FORMED_DOCUMENT, PostgreSQLParserXML_IS_WELL_FORMED_CONTENT, PostgreSQLParserXPATH, PostgreSQLParserXPATH_EXISTS, PostgreSQLParserREVERSE, PostgreSQLParserLOG, PostgreSQLParserABS, PostgreSQLParserCBRT, PostgreSQLParserCEIL, PostgreSQLParserCEILING, PostgreSQLParserDEGREES, PostgreSQLParserDIV, PostgreSQLParserEXP, PostgreSQLParserFACTORIAL, PostgreSQLParserFLOOR, PostgreSQLParserGCD, PostgreSQLParserLCM, PostgreSQLParserLN, PostgreSQLParserLOG10, PostgreSQLParserMIN_SCALE, PostgreSQLParserMOD, PostgreSQLParserPI, PostgreSQLParserPOWER, PostgreSQLParserRADIANS, PostgreSQLParserROUND, PostgreSQLParserSCALE, PostgreSQLParserSIGN, PostgreSQLParserSQRT, PostgreSQLParserTRIM_SCALE, PostgreSQLParserTRUNC, PostgreSQLParserWIDTH_BUCKET, PostgreSQLParserRANDOM, PostgreSQLParserSETSEED, PostgreSQLParserACOS, PostgreSQLParserACOSD, PostgreSQLParserASIN, PostgreSQLParserASIND, PostgreSQLParserATAN, PostgreSQLParserATAND, PostgreSQLParserATAN2, PostgreSQLParserATAN2D, PostgreSQLParserCOS, PostgreSQLParserCOSD, PostgreSQLParserCOT, PostgreSQLParserCOTD, PostgreSQLParserSIN, PostgreSQLParserSIND, PostgreSQLParserTAN, PostgreSQLParserTAND, PostgreSQLParserSINH, PostgreSQLParserCOSH, PostgreSQLParserTANH, PostgreSQLParserASINH, PostgreSQLParserACOSH, PostgreSQLParserATANH, PostgreSQLParserBIT_LENGTH, PostgreSQLParserCHAR_LENGTH, PostgreSQLParserCHARACTER_LENGTH, PostgreSQLParserLOWER, PostgreSQLParserOCTET_LENGTH, PostgreSQLParserUPPER, PostgreSQLParserASCII, PostgreSQLParserBTRIM, PostgreSQLParserCHR, PostgreSQLParserCONCAT, PostgreSQLParserCONCAT_WS, PostgreSQLParserFORMAT, PostgreSQLParserINITCAP, PostgreSQLParserLENGTH, PostgreSQLParserLPAD, PostgreSQLParserLTRIM, PostgreSQLParserMD5, PostgreSQLParserPARSE_IDENT, PostgreSQLParserPG_CLIENT_ENCODING, PostgreSQLParserQUOTE_IDENT, PostgreSQLParserQUOTE_LITERAL, PostgreSQLParserQUOTE_NULLABLE, PostgreSQLParserREGEXP_COUNT, PostgreSQLParserREGEXP_INSTR, PostgreSQLParserREGEXP_LIKE, PostgreSQLParserREGEXP_MATCH, PostgreSQLParserREGEXP_MATCHES, PostgreSQLParserREGEXP_REPLACE, PostgreSQLParserREGEXP_SPLIT_TO_ARRAY, PostgreSQLParserREGEXP_SPLIT_TO_TABLE, PostgreSQLParserREGEXP_SUBSTR, PostgreSQLParserREPEAT, PostgreSQLParserRPAD, PostgreSQLParserRTRIM, PostgreSQLParserSPLIT_PART, PostgreSQLParserSTARTS_WITH, PostgreSQLParserSTRING_TO_ARRAY, PostgreSQLParserSTRING_TO_TABLE, PostgreSQLParserSTRPOS, PostgreSQLParserSUBSTR, PostgreSQLParserTO_ASCII, PostgreSQLParserTO_HEX, PostgreSQLParserTRANSLATE, PostgreSQLParserUNISTR, PostgreSQLParserAGE, PostgreSQLParserCLOCK_TIMESTAMP, PostgreSQLParserDATE_BIN, PostgreSQLParserDATE_PART, PostgreSQLParserDATE_TRUNC, PostgreSQLParserISFINITE, PostgreSQLParserJUSTIFY_DAYS, PostgreSQLParserJUSTIFY_HOURS, PostgreSQLParserJUSTIFY_INTERVAL, PostgreSQLParserMAKE_DATE, PostgreSQLParserMAKE_INTERVAL, PostgreSQLParserMAKE_TIME, PostgreSQLParserMAKE_TIMESTAMP, PostgreSQLParserMAKE_TIMESTAMPTZ, PostgreSQLParserNOW, PostgreSQLParserSTATEMENT_TIMESTAMP, PostgreSQLParserTIMEOFDAY, PostgreSQLParserTRANSACTION_TIMESTAMP, PostgreSQLParserTO_TIMESTAMP, PostgreSQLParserTO_CHAR, PostgreSQLParserTO_DATE, PostgreSQLParserTO_NUMBER:
			{
				p.SetState(5468)
				p.Builtin_function_name()
			}

		case PostgreSQLParserAND, PostgreSQLParserARRAY, PostgreSQLParserCOLLATE, PostgreSQLParserCOLUMN, PostgreSQLParserCONSTRAINT, PostgreSQLParserDEFAULT, PostgreSQLParserDO, PostgreSQLParserFETCH, PostgreSQLParserTABLE, PostgreSQLParserAUTHORIZATION, PostgreSQLParserBINARY, PostgreSQLParserCOLLATION, PostgreSQLParserCONCURRENTLY, PostgreSQLParserCROSS, PostgreSQLParserCURRENT_SCHEMA, PostgreSQLParserFREEZE, PostgreSQLParserFULL, PostgreSQLParserILIKE, PostgreSQLParserINNER_P, PostgreSQLParserIS, PostgreSQLParserISNULL, PostgreSQLParserJOIN, PostgreSQLParserLIKE, PostgreSQLParserNATURAL, PostgreSQLParserNOTNULL, PostgreSQLParserOUTER_P, PostgreSQLParserOVER, PostgreSQLParserOVERLAPS, PostgreSQLParserSIMILAR, PostgreSQLParserVERBOSE, PostgreSQLParserABORT_P, PostgreSQLParserABSOLUTE_P, PostgreSQLParserACCESS, PostgreSQLParserACTION, PostgreSQLParserADD_P, PostgreSQLParserADMIN, PostgreSQLParserAFTER, PostgreSQLParserAGGREGATE, PostgreSQLParserALSO, PostgreSQLParserALTER, PostgreSQLParserALWAYS, PostgreSQLParserASSERTION, PostgreSQLParserASSIGNMENT, PostgreSQLParserAT, PostgreSQLParserATTRIBUTE, PostgreSQLParserBACKWARD, PostgreSQLParserBEFORE, PostgreSQLParserBEGIN_P, PostgreSQLParserBY, PostgreSQLParserCACHE, PostgreSQLParserCALLED, PostgreSQLParserCASCADE, PostgreSQLParserCASCADED, PostgreSQLParserCATALOG, PostgreSQLParserCHAIN, PostgreSQLParserCHARACTERISTICS, PostgreSQLParserCHECKPOINT, PostgreSQLParserCLASS, PostgreSQLParserCLOSE, PostgreSQLParserCLUSTER, PostgreSQLParserCOMMENT, PostgreSQLParserCOMMENTS, PostgreSQLParserCOMMIT, PostgreSQLParserCOMMITTED, PostgreSQLParserCONFIGURATION, PostgreSQLParserCONNECTION, PostgreSQLParserCONSTRAINTS, PostgreSQLParserCONTENT_P, PostgreSQLParserCONTINUE_P, PostgreSQLParserCONVERSION_P, PostgreSQLParserCOPY, PostgreSQLParserCOST, PostgreSQLParserCSV, PostgreSQLParserCURSOR, PostgreSQLParserCYCLE, PostgreSQLParserDATA_P, PostgreSQLParserDATABASE, PostgreSQLParserDAY_P, PostgreSQLParserDEALLOCATE, PostgreSQLParserDECLARE, PostgreSQLParserDEFAULTS, PostgreSQLParserDEFERRED, PostgreSQLParserDEFINER, PostgreSQLParserDELETE_P, PostgreSQLParserDELIMITER, PostgreSQLParserDELIMITERS, PostgreSQLParserDICTIONARY, PostgreSQLParserDISABLE_P, PostgreSQLParserDISCARD, PostgreSQLParserDOCUMENT_P, PostgreSQLParserDOMAIN_P, PostgreSQLParserDOUBLE_P, PostgreSQLParserDROP, PostgreSQLParserEACH, PostgreSQLParserENABLE_P, PostgreSQLParserENCODING, PostgreSQLParserENCRYPTED, PostgreSQLParserENUM_P, PostgreSQLParserESCAPE, PostgreSQLParserEVENT, PostgreSQLParserEXCLUDE, PostgreSQLParserEXCLUDING, PostgreSQLParserEXCLUSIVE, PostgreSQLParserEXECUTE, PostgreSQLParserEXPLAIN, PostgreSQLParserEXTENSION, PostgreSQLParserEXTERNAL, PostgreSQLParserFAMILY, PostgreSQLParserFIRST_P, PostgreSQLParserFOLLOWING, PostgreSQLParserFORCE, PostgreSQLParserFORWARD, PostgreSQLParserFUNCTION, PostgreSQLParserFUNCTIONS, PostgreSQLParserGLOBAL, PostgreSQLParserGRANTED, PostgreSQLParserHANDLER, PostgreSQLParserHEADER_P, PostgreSQLParserHOLD, PostgreSQLParserHOUR_P, PostgreSQLParserIDENTITY_P, PostgreSQLParserIF_P, PostgreSQLParserIMMEDIATE, PostgreSQLParserIMMUTABLE, PostgreSQLParserIMPLICIT_P, PostgreSQLParserINCLUDING, PostgreSQLParserINCREMENT, PostgreSQLParserINDEX, PostgreSQLParserINDEXES, PostgreSQLParserINHERIT, PostgreSQLParserINHERITS, PostgreSQLParserINLINE_P, PostgreSQLParserINSENSITIVE, PostgreSQLParserINSERT, PostgreSQLParserINSTEAD, PostgreSQLParserINVOKER, PostgreSQLParserISOLATION, PostgreSQLParserKEY, PostgreSQLParserLABEL, PostgreSQLParserLANGUAGE, PostgreSQLParserLARGE_P, PostgreSQLParserLAST_P, PostgreSQLParserLEAKPROOF, PostgreSQLParserLEVEL, PostgreSQLParserLISTEN, PostgreSQLParserLOAD, PostgreSQLParserLOCAL, PostgreSQLParserLOCATION, PostgreSQLParserLOCK_P, PostgreSQLParserMAPPING, PostgreSQLParserMATCH, PostgreSQLParserMATERIALIZED, PostgreSQLParserMAXVALUE, PostgreSQLParserMINUTE_P, PostgreSQLParserMINVALUE, PostgreSQLParserMODE, PostgreSQLParserMONTH_P, PostgreSQLParserMOVE, PostgreSQLParserNAME_P, PostgreSQLParserNAMES, PostgreSQLParserNEXT, PostgreSQLParserNO, PostgreSQLParserNOTHING, PostgreSQLParserNOTIFY, PostgreSQLParserNOWAIT, PostgreSQLParserNULLS_P, PostgreSQLParserOBJECT_P, PostgreSQLParserOF, PostgreSQLParserOFF, PostgreSQLParserOIDS, PostgreSQLParserOPERATOR, PostgreSQLParserOPTION, PostgreSQLParserOPTIONS, PostgreSQLParserOWNED, PostgreSQLParserOWNER, PostgreSQLParserPARSER, PostgreSQLParserPARTIAL, PostgreSQLParserPARTITION, PostgreSQLParserPASSING, PostgreSQLParserPASSWORD, PostgreSQLParserPLANS, PostgreSQLParserPRECEDING, PostgreSQLParserPREPARE, PostgreSQLParserPREPARED, PostgreSQLParserPRESERVE, PostgreSQLParserPRIOR, PostgreSQLParserPRIVILEGES, PostgreSQLParserPROCEDURAL, PostgreSQLParserPROCEDURE, PostgreSQLParserPROGRAM, PostgreSQLParserQUOTE, PostgreSQLParserRANGE, PostgreSQLParserREAD, PostgreSQLParserREASSIGN, PostgreSQLParserRECHECK, PostgreSQLParserRECURSIVE, PostgreSQLParserREF, PostgreSQLParserREFRESH, PostgreSQLParserREINDEX, PostgreSQLParserRELATIVE_P, PostgreSQLParserRELEASE, PostgreSQLParserRENAME, PostgreSQLParserREPEATABLE, PostgreSQLParserREPLICA, PostgreSQLParserRESET, PostgreSQLParserRESTART, PostgreSQLParserRESTRICT, PostgreSQLParserRETURNS, PostgreSQLParserREVOKE, PostgreSQLParserROLE, PostgreSQLParserROLLBACK, PostgreSQLParserROWS, PostgreSQLParserRULE, PostgreSQLParserSAVEPOINT, PostgreSQLParserSCHEMA, PostgreSQLParserSCROLL, PostgreSQLParserSEARCH, PostgreSQLParserSECOND_P, PostgreSQLParserSECURITY, PostgreSQLParserSEQUENCE, PostgreSQLParserSEQUENCES, PostgreSQLParserSERIALIZABLE, PostgreSQLParserSERVER, PostgreSQLParserSESSION, PostgreSQLParserSET, PostgreSQLParserSHARE, PostgreSQLParserSHOW, PostgreSQLParserSIMPLE, PostgreSQLParserSNAPSHOT, PostgreSQLParserSTABLE, PostgreSQLParserSTANDALONE_P, PostgreSQLParserSTART, PostgreSQLParserSTATEMENT, PostgreSQLParserSTATISTICS, PostgreSQLParserSTDIN, PostgreSQLParserSTDOUT, PostgreSQLParserSTORAGE, PostgreSQLParserSTRICT_P, PostgreSQLParserSTRIP_P, PostgreSQLParserSYSID, PostgreSQLParserSYSTEM_P, PostgreSQLParserTABLES, PostgreSQLParserTABLESPACE, PostgreSQLParserTEMP, PostgreSQLParserTEMPLATE, PostgreSQLParserTEMPORARY, PostgreSQLParserTEXT_P, PostgreSQLParserTRANSACTION, PostgreSQLParserTRIGGER, PostgreSQLParserTRUNCATE, PostgreSQLParserTRUSTED, PostgreSQLParserTYPE_P, PostgreSQLParserTYPES_P, PostgreSQLParserUNBOUNDED, PostgreSQLParserUNCOMMITTED, PostgreSQLParserUNENCRYPTED, PostgreSQLParserUNKNOWN, PostgreSQLParserUNLISTEN, PostgreSQLParserUNLOGGED, PostgreSQLParserUNTIL, PostgreSQLParserUPDATE, PostgreSQLParserVACUUM, PostgreSQLParserVALID, PostgreSQLParserVALIDATE, PostgreSQLParserVALIDATOR, PostgreSQLParserVARYING, PostgreSQLParserVERSION_P, PostgreSQLParserVIEW, PostgreSQLParserVOLATILE, PostgreSQLParserWHITESPACE_P, PostgreSQLParserWITHOUT, PostgreSQLParserWORK, PostgreSQLParserWRAPPER, PostgreSQLParserWRITE, PostgreSQLParserXML_P, PostgreSQLParserYEAR_P, PostgreSQLParserYES_P, PostgreSQLParserZONE, PostgreSQLParserCALL, PostgreSQLParserCURRENT_P, PostgreSQLParserATTACH, PostgreSQLParserDETACH, PostgreSQLParserEXPRESSION, PostgreSQLParserGENERATED, PostgreSQLParserLOGGED, PostgreSQLParserSTORED, PostgreSQLParserINCLUDE, PostgreSQLParserROUTINE, PostgreSQLParserTRANSFORM, PostgreSQLParserIMPORT_P, PostgreSQLParserPOLICY, PostgreSQLParserMETHOD, PostgreSQLParserREFERENCING, PostgreSQLParserNEW, PostgreSQLParserOLD, PostgreSQLParserVALUE_P, PostgreSQLParserSUBSCRIPTION, PostgreSQLParserPUBLICATION, PostgreSQLParserROUTINES, PostgreSQLParserSCHEMAS, PostgreSQLParserPROCEDURES, PostgreSQLParserINPUT_P, PostgreSQLParserSUPPORT, PostgreSQLParserPARALLEL, PostgreSQLParserSQL_P, PostgreSQLParserDEPENDS, PostgreSQLParserOVERRIDING, PostgreSQLParserCONFLICT, PostgreSQLParserSKIP_P, PostgreSQLParserLOCKED, PostgreSQLParserTIES, PostgreSQLParserROLLUP, PostgreSQLParserCUBE, PostgreSQLParserSETS, PostgreSQLParserTABLESAMPLE, PostgreSQLParserORDINALITY, PostgreSQLParserCOLUMNS, PostgreSQLParserROWTYPE, PostgreSQLParserNORMALIZED, PostgreSQLParserWITHIN, PostgreSQLParserFILTER, PostgreSQLParserGROUPS, PostgreSQLParserOTHERS, PostgreSQLParserNFC, PostgreSQLParserNFD, PostgreSQLParserNFKC, PostgreSQLParserNFKD, PostgreSQLParserUESCAPE, PostgreSQLParserVIEWS, PostgreSQLParserDUMP, PostgreSQLParserPRINT_STRICT_PARAMS, PostgreSQLParserVARIABLE_CONFLICT, PostgreSQLParserERROR, PostgreSQLParserUSE_VARIABLE, PostgreSQLParserUSE_COLUMN, PostgreSQLParserALIAS, PostgreSQLParserCONSTANT, PostgreSQLParserPERFORM, PostgreSQLParserGET, PostgreSQLParserDIAGNOSTICS, PostgreSQLParserSTACKED, PostgreSQLParserELSIF, PostgreSQLParserSLICE, PostgreSQLParserEXIT, PostgreSQLParserRETURN, PostgreSQLParserQUERY, PostgreSQLParserRAISE, PostgreSQLParserSQLSTATE, PostgreSQLParserDEBUG, PostgreSQLParserINFO, PostgreSQLParserNOTICE, PostgreSQLParserWARNING, PostgreSQLParserEXCEPTION, PostgreSQLParserASSERT, PostgreSQLParserOPEN, PostgreSQLParserIdentifier, PostgreSQLParserQuotedIdentifier, PostgreSQLParserUnicodeQuotedIdentifier, PostgreSQLParserPLSQLVARIABLENAME, PostgreSQLParserPLSQLIDENTIFIER:
			{
				p.SetState(5469)
				p.Type_function_name()
			}

		case PostgreSQLParserLEFT:
			{
				p.SetState(5470)
				p.Match(PostgreSQLParserLEFT)
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}

		case PostgreSQLParserRIGHT:
			{
				p.SetState(5471)
				p.Match(PostgreSQLParserRIGHT)
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}

		default:
			p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
			goto errorExit
		}
		{
			p.SetState(5474)
			p.Attrs()
		}
		{
			p.SetState(5475)
			p.Match(PostgreSQLParserPERCENT)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5476)
			p.Match(PostgreSQLParserTYPE_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case antlr.ATNInvalidAltNumber:
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IFunc_arg_with_defaultContext is an interface to support dynamic dispatch.
type IFunc_arg_with_defaultContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Func_arg() IFunc_argContext
	A_expr() IA_exprContext
	DEFAULT() antlr.TerminalNode
	EQUAL() antlr.TerminalNode

	// IsFunc_arg_with_defaultContext differentiates from other interfaces.
	IsFunc_arg_with_defaultContext()
}

type Func_arg_with_defaultContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyFunc_arg_with_defaultContext() *Func_arg_with_defaultContext {
	var p = new(Func_arg_with_defaultContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_func_arg_with_default
	return p
}

func InitEmptyFunc_arg_with_defaultContext(p *Func_arg_with_defaultContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_func_arg_with_default
}

func (*Func_arg_with_defaultContext) IsFunc_arg_with_defaultContext() {}

func NewFunc_arg_with_defaultContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Func_arg_with_defaultContext {
	var p = new(Func_arg_with_defaultContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_func_arg_with_default

	return p
}

func (s *Func_arg_with_defaultContext) GetParser() antlr.Parser { return s.parser }

func (s *Func_arg_with_defaultContext) Func_arg() IFunc_argContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IFunc_argContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IFunc_argContext)
}

func (s *Func_arg_with_defaultContext) A_expr() IA_exprContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IA_exprContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IA_exprContext)
}

func (s *Func_arg_with_defaultContext) DEFAULT() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserDEFAULT, 0)
}

func (s *Func_arg_with_defaultContext) EQUAL() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserEQUAL, 0)
}

func (s *Func_arg_with_defaultContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Func_arg_with_defaultContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Func_arg_with_defaultContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterFunc_arg_with_default(s)
	}
}

func (s *Func_arg_with_defaultContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitFunc_arg_with_default(s)
	}
}

func (s *Func_arg_with_defaultContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitFunc_arg_with_default(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Func_arg_with_default() (localctx IFunc_arg_with_defaultContext) {
	localctx = NewFunc_arg_with_defaultContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 642, PostgreSQLParserRULE_func_arg_with_default)
	var _la int

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(5480)
		p.Func_arg()
	}
	p.SetState(5483)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}
	_la = p.GetTokenStream().LA(1)

	if _la == PostgreSQLParserEQUAL || _la == PostgreSQLParserDEFAULT {
		{
			p.SetState(5481)
			_la = p.GetTokenStream().LA(1)

			if !(_la == PostgreSQLParserEQUAL || _la == PostgreSQLParserDEFAULT) {
				p.GetErrorHandler().RecoverInline(p)
			} else {
				p.GetErrorHandler().ReportMatch(p)
				p.Consume()
			}
		}
		{
			p.SetState(5482)
			p.A_expr()
		}

	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IAggr_argContext is an interface to support dynamic dispatch.
type IAggr_argContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Func_arg() IFunc_argContext

	// IsAggr_argContext differentiates from other interfaces.
	IsAggr_argContext()
}

type Aggr_argContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyAggr_argContext() *Aggr_argContext {
	var p = new(Aggr_argContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_aggr_arg
	return p
}

func InitEmptyAggr_argContext(p *Aggr_argContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_aggr_arg
}

func (*Aggr_argContext) IsAggr_argContext() {}

func NewAggr_argContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Aggr_argContext {
	var p = new(Aggr_argContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_aggr_arg

	return p
}

func (s *Aggr_argContext) GetParser() antlr.Parser { return s.parser }

func (s *Aggr_argContext) Func_arg() IFunc_argContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IFunc_argContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IFunc_argContext)
}

func (s *Aggr_argContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Aggr_argContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Aggr_argContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterAggr_arg(s)
	}
}

func (s *Aggr_argContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitAggr_arg(s)
	}
}

func (s *Aggr_argContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitAggr_arg(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Aggr_arg() (localctx IAggr_argContext) {
	localctx = NewAggr_argContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 644, PostgreSQLParserRULE_aggr_arg)
	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(5485)
		p.Func_arg()
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IAggr_argsContext is an interface to support dynamic dispatch.
type IAggr_argsContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	OPEN_PAREN() antlr.TerminalNode
	CLOSE_PAREN() antlr.TerminalNode
	STAR() antlr.TerminalNode
	AllAggr_args_list() []IAggr_args_listContext
	Aggr_args_list(i int) IAggr_args_listContext
	ORDER() antlr.TerminalNode
	BY() antlr.TerminalNode

	// IsAggr_argsContext differentiates from other interfaces.
	IsAggr_argsContext()
}

type Aggr_argsContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyAggr_argsContext() *Aggr_argsContext {
	var p = new(Aggr_argsContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_aggr_args
	return p
}

func InitEmptyAggr_argsContext(p *Aggr_argsContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_aggr_args
}

func (*Aggr_argsContext) IsAggr_argsContext() {}

func NewAggr_argsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Aggr_argsContext {
	var p = new(Aggr_argsContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_aggr_args

	return p
}

func (s *Aggr_argsContext) GetParser() antlr.Parser { return s.parser }

func (s *Aggr_argsContext) OPEN_PAREN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserOPEN_PAREN, 0)
}

func (s *Aggr_argsContext) CLOSE_PAREN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCLOSE_PAREN, 0)
}

func (s *Aggr_argsContext) STAR() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserSTAR, 0)
}

func (s *Aggr_argsContext) AllAggr_args_list() []IAggr_args_listContext {
	children := s.GetChildren()
	len := 0
	for _, ctx := range children {
		if _, ok := ctx.(IAggr_args_listContext); ok {
			len++
		}
	}

	tst := make([]IAggr_args_listContext, len)
	i := 0
	for _, ctx := range children {
		if t, ok := ctx.(IAggr_args_listContext); ok {
			tst[i] = t.(IAggr_args_listContext)
			i++
		}
	}

	return tst
}

func (s *Aggr_argsContext) Aggr_args_list(i int) IAggr_args_listContext {
	var t antlr.RuleContext
	j := 0
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IAggr_args_listContext); ok {
			if j == i {
				t = ctx.(antlr.RuleContext)
				break
			}
			j++
		}
	}

	if t == nil {
		return nil
	}

	return t.(IAggr_args_listContext)
}

func (s *Aggr_argsContext) ORDER() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserORDER, 0)
}

func (s *Aggr_argsContext) BY() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserBY, 0)
}

func (s *Aggr_argsContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Aggr_argsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Aggr_argsContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterAggr_args(s)
	}
}

func (s *Aggr_argsContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitAggr_args(s)
	}
}

func (s *Aggr_argsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitAggr_args(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Aggr_args() (localctx IAggr_argsContext) {
	localctx = NewAggr_argsContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 646, PostgreSQLParserRULE_aggr_args)
	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(5487)
		p.Match(PostgreSQLParserOPEN_PAREN)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	p.SetState(5498)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 283, p.GetParserRuleContext()) {
	case 1:
		{
			p.SetState(5488)
			p.Match(PostgreSQLParserSTAR)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 2:
		{
			p.SetState(5489)
			p.Aggr_args_list()
		}

	case 3:
		{
			p.SetState(5490)
			p.Match(PostgreSQLParserORDER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5491)
			p.Match(PostgreSQLParserBY)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5492)
			p.Aggr_args_list()
		}

	case 4:
		{
			p.SetState(5493)
			p.Aggr_args_list()
		}
		{
			p.SetState(5494)
			p.Match(PostgreSQLParserORDER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5495)
			p.Match(PostgreSQLParserBY)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5496)
			p.Aggr_args_list()
		}

	case antlr.ATNInvalidAltNumber:
		goto errorExit
	}
	{
		p.SetState(5500)
		p.Match(PostgreSQLParserCLOSE_PAREN)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IAggr_args_listContext is an interface to support dynamic dispatch.
type IAggr_args_listContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	AllAggr_arg() []IAggr_argContext
	Aggr_arg(i int) IAggr_argContext
	AllCOMMA() []antlr.TerminalNode
	COMMA(i int) antlr.TerminalNode

	// IsAggr_args_listContext differentiates from other interfaces.
	IsAggr_args_listContext()
}

type Aggr_args_listContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyAggr_args_listContext() *Aggr_args_listContext {
	var p = new(Aggr_args_listContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_aggr_args_list
	return p
}

func InitEmptyAggr_args_listContext(p *Aggr_args_listContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_aggr_args_list
}

func (*Aggr_args_listContext) IsAggr_args_listContext() {}

func NewAggr_args_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Aggr_args_listContext {
	var p = new(Aggr_args_listContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_aggr_args_list

	return p
}

func (s *Aggr_args_listContext) GetParser() antlr.Parser { return s.parser }

func (s *Aggr_args_listContext) AllAggr_arg() []IAggr_argContext {
	children := s.GetChildren()
	len := 0
	for _, ctx := range children {
		if _, ok := ctx.(IAggr_argContext); ok {
			len++
		}
	}

	tst := make([]IAggr_argContext, len)
	i := 0
	for _, ctx := range children {
		if t, ok := ctx.(IAggr_argContext); ok {
			tst[i] = t.(IAggr_argContext)
			i++
		}
	}

	return tst
}

func (s *Aggr_args_listContext) Aggr_arg(i int) IAggr_argContext {
	var t antlr.RuleContext
	j := 0
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IAggr_argContext); ok {
			if j == i {
				t = ctx.(antlr.RuleContext)
				break
			}
			j++
		}
	}

	if t == nil {
		return nil
	}

	return t.(IAggr_argContext)
}

func (s *Aggr_args_listContext) AllCOMMA() []antlr.TerminalNode {
	return s.GetTokens(PostgreSQLParserCOMMA)
}

func (s *Aggr_args_listContext) COMMA(i int) antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCOMMA, i)
}

func (s *Aggr_args_listContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Aggr_args_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Aggr_args_listContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterAggr_args_list(s)
	}
}

func (s *Aggr_args_listContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitAggr_args_list(s)
	}
}

func (s *Aggr_args_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitAggr_args_list(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Aggr_args_list() (localctx IAggr_args_listContext) {
	localctx = NewAggr_args_listContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 648, PostgreSQLParserRULE_aggr_args_list)
	var _la int

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(5502)
		p.Aggr_arg()
	}
	p.SetState(5507)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}
	_la = p.GetTokenStream().LA(1)

	for _la == PostgreSQLParserCOMMA {
		{
			p.SetState(5503)
			p.Match(PostgreSQLParserCOMMA)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5504)
			p.Aggr_arg()
		}

		p.SetState(5509)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}
		_la = p.GetTokenStream().LA(1)
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IAggregate_with_argtypesContext is an interface to support dynamic dispatch.
type IAggregate_with_argtypesContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Func_name() IFunc_nameContext
	Aggr_args() IAggr_argsContext

	// IsAggregate_with_argtypesContext differentiates from other interfaces.
	IsAggregate_with_argtypesContext()
}

type Aggregate_with_argtypesContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyAggregate_with_argtypesContext() *Aggregate_with_argtypesContext {
	var p = new(Aggregate_with_argtypesContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_aggregate_with_argtypes
	return p
}

func InitEmptyAggregate_with_argtypesContext(p *Aggregate_with_argtypesContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_aggregate_with_argtypes
}

func (*Aggregate_with_argtypesContext) IsAggregate_with_argtypesContext() {}

func NewAggregate_with_argtypesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Aggregate_with_argtypesContext {
	var p = new(Aggregate_with_argtypesContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_aggregate_with_argtypes

	return p
}

func (s *Aggregate_with_argtypesContext) GetParser() antlr.Parser { return s.parser }

func (s *Aggregate_with_argtypesContext) Func_name() IFunc_nameContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IFunc_nameContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IFunc_nameContext)
}

func (s *Aggregate_with_argtypesContext) Aggr_args() IAggr_argsContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IAggr_argsContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IAggr_argsContext)
}

func (s *Aggregate_with_argtypesContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Aggregate_with_argtypesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Aggregate_with_argtypesContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterAggregate_with_argtypes(s)
	}
}

func (s *Aggregate_with_argtypesContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitAggregate_with_argtypes(s)
	}
}

func (s *Aggregate_with_argtypesContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitAggregate_with_argtypes(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Aggregate_with_argtypes() (localctx IAggregate_with_argtypesContext) {
	localctx = NewAggregate_with_argtypesContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 650, PostgreSQLParserRULE_aggregate_with_argtypes)
	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(5510)
		p.Func_name()
	}
	{
		p.SetState(5511)
		p.Aggr_args()
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IAggregate_with_argtypes_listContext is an interface to support dynamic dispatch.
type IAggregate_with_argtypes_listContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	AllAggregate_with_argtypes() []IAggregate_with_argtypesContext
	Aggregate_with_argtypes(i int) IAggregate_with_argtypesContext
	AllCOMMA() []antlr.TerminalNode
	COMMA(i int) antlr.TerminalNode

	// IsAggregate_with_argtypes_listContext differentiates from other interfaces.
	IsAggregate_with_argtypes_listContext()
}

type Aggregate_with_argtypes_listContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyAggregate_with_argtypes_listContext() *Aggregate_with_argtypes_listContext {
	var p = new(Aggregate_with_argtypes_listContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_aggregate_with_argtypes_list
	return p
}

func InitEmptyAggregate_with_argtypes_listContext(p *Aggregate_with_argtypes_listContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_aggregate_with_argtypes_list
}

func (*Aggregate_with_argtypes_listContext) IsAggregate_with_argtypes_listContext() {}

func NewAggregate_with_argtypes_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Aggregate_with_argtypes_listContext {
	var p = new(Aggregate_with_argtypes_listContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_aggregate_with_argtypes_list

	return p
}

func (s *Aggregate_with_argtypes_listContext) GetParser() antlr.Parser { return s.parser }

func (s *Aggregate_with_argtypes_listContext) AllAggregate_with_argtypes() []IAggregate_with_argtypesContext {
	children := s.GetChildren()
	len := 0
	for _, ctx := range children {
		if _, ok := ctx.(IAggregate_with_argtypesContext); ok {
			len++
		}
	}

	tst := make([]IAggregate_with_argtypesContext, len)
	i := 0
	for _, ctx := range children {
		if t, ok := ctx.(IAggregate_with_argtypesContext); ok {
			tst[i] = t.(IAggregate_with_argtypesContext)
			i++
		}
	}

	return tst
}

func (s *Aggregate_with_argtypes_listContext) Aggregate_with_argtypes(i int) IAggregate_with_argtypesContext {
	var t antlr.RuleContext
	j := 0
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IAggregate_with_argtypesContext); ok {
			if j == i {
				t = ctx.(antlr.RuleContext)
				break
			}
			j++
		}
	}

	if t == nil {
		return nil
	}

	return t.(IAggregate_with_argtypesContext)
}

func (s *Aggregate_with_argtypes_listContext) AllCOMMA() []antlr.TerminalNode {
	return s.GetTokens(PostgreSQLParserCOMMA)
}

func (s *Aggregate_with_argtypes_listContext) COMMA(i int) antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCOMMA, i)
}

func (s *Aggregate_with_argtypes_listContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Aggregate_with_argtypes_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Aggregate_with_argtypes_listContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterAggregate_with_argtypes_list(s)
	}
}

func (s *Aggregate_with_argtypes_listContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitAggregate_with_argtypes_list(s)
	}
}

func (s *Aggregate_with_argtypes_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitAggregate_with_argtypes_list(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Aggregate_with_argtypes_list() (localctx IAggregate_with_argtypes_listContext) {
	localctx = NewAggregate_with_argtypes_listContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 652, PostgreSQLParserRULE_aggregate_with_argtypes_list)
	var _la int

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(5513)
		p.Aggregate_with_argtypes()
	}
	p.SetState(5518)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}
	_la = p.GetTokenStream().LA(1)

	for _la == PostgreSQLParserCOMMA {
		{
			p.SetState(5514)
			p.Match(PostgreSQLParserCOMMA)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5515)
			p.Aggregate_with_argtypes()
		}

		p.SetState(5520)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}
		_la = p.GetTokenStream().LA(1)
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// ICreatefunc_opt_listContext is an interface to support dynamic dispatch.
type ICreatefunc_opt_listContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	AllCreatefunc_opt_item() []ICreatefunc_opt_itemContext
	Createfunc_opt_item(i int) ICreatefunc_opt_itemContext

	// IsCreatefunc_opt_listContext differentiates from other interfaces.
	IsCreatefunc_opt_listContext()
}

type Createfunc_opt_listContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyCreatefunc_opt_listContext() *Createfunc_opt_listContext {
	var p = new(Createfunc_opt_listContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_createfunc_opt_list
	return p
}

func InitEmptyCreatefunc_opt_listContext(p *Createfunc_opt_listContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_createfunc_opt_list
}

func (*Createfunc_opt_listContext) IsCreatefunc_opt_listContext() {}

func NewCreatefunc_opt_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Createfunc_opt_listContext {
	var p = new(Createfunc_opt_listContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_createfunc_opt_list

	return p
}

func (s *Createfunc_opt_listContext) GetParser() antlr.Parser { return s.parser }

func (s *Createfunc_opt_listContext) AllCreatefunc_opt_item() []ICreatefunc_opt_itemContext {
	children := s.GetChildren()
	len := 0
	for _, ctx := range children {
		if _, ok := ctx.(ICreatefunc_opt_itemContext); ok {
			len++
		}
	}

	tst := make([]ICreatefunc_opt_itemContext, len)
	i := 0
	for _, ctx := range children {
		if t, ok := ctx.(ICreatefunc_opt_itemContext); ok {
			tst[i] = t.(ICreatefunc_opt_itemContext)
			i++
		}
	}

	return tst
}

func (s *Createfunc_opt_listContext) Createfunc_opt_item(i int) ICreatefunc_opt_itemContext {
	var t antlr.RuleContext
	j := 0
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ICreatefunc_opt_itemContext); ok {
			if j == i {
				t = ctx.(antlr.RuleContext)
				break
			}
			j++
		}
	}

	if t == nil {
		return nil
	}

	return t.(ICreatefunc_opt_itemContext)
}

func (s *Createfunc_opt_listContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Createfunc_opt_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Createfunc_opt_listContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterCreatefunc_opt_list(s)
	}
}

func (s *Createfunc_opt_listContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitCreatefunc_opt_list(s)
	}
}

func (s *Createfunc_opt_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitCreatefunc_opt_list(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Createfunc_opt_list() (localctx ICreatefunc_opt_listContext) {
	localctx = NewCreatefunc_opt_listContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 654, PostgreSQLParserRULE_createfunc_opt_list)
	var _alt int

	p.EnterOuterAlt(localctx, 1)
	p.SetState(5522)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}
	_alt = 1
	for ok := true; ok; ok = _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
		switch _alt {
		case 1:
			{
				p.SetState(5521)
				p.Createfunc_opt_item()
			}

		default:
			p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
			goto errorExit
		}

		p.SetState(5524)
		p.GetErrorHandler().Sync(p)
		_alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 286, p.GetParserRuleContext())
		if p.HasError() {
			goto errorExit
		}
	}

	// ParseRoutineBody(_localctx)

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// ICommon_func_opt_itemContext is an interface to support dynamic dispatch.
type ICommon_func_opt_itemContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	CALLED() antlr.TerminalNode
	ON() antlr.TerminalNode
	AllNULL_P() []antlr.TerminalNode
	NULL_P(i int) antlr.TerminalNode
	INPUT_P() antlr.TerminalNode
	RETURNS() antlr.TerminalNode
	STRICT_P() antlr.TerminalNode
	IMMUTABLE() antlr.TerminalNode
	STABLE() antlr.TerminalNode
	VOLATILE() antlr.TerminalNode
	EXTERNAL() antlr.TerminalNode
	SECURITY() antlr.TerminalNode
	DEFINER() antlr.TerminalNode
	INVOKER() antlr.TerminalNode
	LEAKPROOF() antlr.TerminalNode
	NOT() antlr.TerminalNode
	COST() antlr.TerminalNode
	Numericonly() INumericonlyContext
	ROWS() antlr.TerminalNode
	SUPPORT() antlr.TerminalNode
	Any_name() IAny_nameContext
	Functionsetresetclause() IFunctionsetresetclauseContext
	PARALLEL() antlr.TerminalNode
	Colid() IColidContext

	// IsCommon_func_opt_itemContext differentiates from other interfaces.
	IsCommon_func_opt_itemContext()
}

type Common_func_opt_itemContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyCommon_func_opt_itemContext() *Common_func_opt_itemContext {
	var p = new(Common_func_opt_itemContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_common_func_opt_item
	return p
}

func InitEmptyCommon_func_opt_itemContext(p *Common_func_opt_itemContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_common_func_opt_item
}

func (*Common_func_opt_itemContext) IsCommon_func_opt_itemContext() {}

func NewCommon_func_opt_itemContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Common_func_opt_itemContext {
	var p = new(Common_func_opt_itemContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_common_func_opt_item

	return p
}

func (s *Common_func_opt_itemContext) GetParser() antlr.Parser { return s.parser }

func (s *Common_func_opt_itemContext) CALLED() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCALLED, 0)
}

func (s *Common_func_opt_itemContext) ON() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserON, 0)
}

func (s *Common_func_opt_itemContext) AllNULL_P() []antlr.TerminalNode {
	return s.GetTokens(PostgreSQLParserNULL_P)
}

func (s *Common_func_opt_itemContext) NULL_P(i int) antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserNULL_P, i)
}

func (s *Common_func_opt_itemContext) INPUT_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserINPUT_P, 0)
}

func (s *Common_func_opt_itemContext) RETURNS() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserRETURNS, 0)
}

func (s *Common_func_opt_itemContext) STRICT_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserSTRICT_P, 0)
}

func (s *Common_func_opt_itemContext) IMMUTABLE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserIMMUTABLE, 0)
}

func (s *Common_func_opt_itemContext) STABLE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserSTABLE, 0)
}

func (s *Common_func_opt_itemContext) VOLATILE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserVOLATILE, 0)
}

func (s *Common_func_opt_itemContext) EXTERNAL() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserEXTERNAL, 0)
}

func (s *Common_func_opt_itemContext) SECURITY() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserSECURITY, 0)
}

func (s *Common_func_opt_itemContext) DEFINER() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserDEFINER, 0)
}

func (s *Common_func_opt_itemContext) INVOKER() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserINVOKER, 0)
}

func (s *Common_func_opt_itemContext) LEAKPROOF() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserLEAKPROOF, 0)
}

func (s *Common_func_opt_itemContext) NOT() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserNOT, 0)
}

func (s *Common_func_opt_itemContext) COST() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCOST, 0)
}

func (s *Common_func_opt_itemContext) Numericonly() INumericonlyContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(INumericonlyContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(INumericonlyContext)
}

func (s *Common_func_opt_itemContext) ROWS() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserROWS, 0)
}

func (s *Common_func_opt_itemContext) SUPPORT() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserSUPPORT, 0)
}

func (s *Common_func_opt_itemContext) Any_name() IAny_nameContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IAny_nameContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IAny_nameContext)
}

func (s *Common_func_opt_itemContext) Functionsetresetclause() IFunctionsetresetclauseContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IFunctionsetresetclauseContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IFunctionsetresetclauseContext)
}

func (s *Common_func_opt_itemContext) PARALLEL() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserPARALLEL, 0)
}

func (s *Common_func_opt_itemContext) Colid() IColidContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IColidContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IColidContext)
}

func (s *Common_func_opt_itemContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Common_func_opt_itemContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Common_func_opt_itemContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterCommon_func_opt_item(s)
	}
}

func (s *Common_func_opt_itemContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitCommon_func_opt_item(s)
	}
}

func (s *Common_func_opt_itemContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitCommon_func_opt_item(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Common_func_opt_item() (localctx ICommon_func_opt_itemContext) {
	localctx = NewCommon_func_opt_itemContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 656, PostgreSQLParserRULE_common_func_opt_item)
	p.SetState(5563)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 287, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(5528)
			p.Match(PostgreSQLParserCALLED)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5529)
			p.Match(PostgreSQLParserON)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5530)
			p.Match(PostgreSQLParserNULL_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5531)
			p.Match(PostgreSQLParserINPUT_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(5532)
			p.Match(PostgreSQLParserRETURNS)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5533)
			p.Match(PostgreSQLParserNULL_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5534)
			p.Match(PostgreSQLParserON)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5535)
			p.Match(PostgreSQLParserNULL_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5536)
			p.Match(PostgreSQLParserINPUT_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 3:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(5537)
			p.Match(PostgreSQLParserSTRICT_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 4:
		p.EnterOuterAlt(localctx, 4)
		{
			p.SetState(5538)
			p.Match(PostgreSQLParserIMMUTABLE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 5:
		p.EnterOuterAlt(localctx, 5)
		{
			p.SetState(5539)
			p.Match(PostgreSQLParserSTABLE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 6:
		p.EnterOuterAlt(localctx, 6)
		{
			p.SetState(5540)
			p.Match(PostgreSQLParserVOLATILE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 7:
		p.EnterOuterAlt(localctx, 7)
		{
			p.SetState(5541)
			p.Match(PostgreSQLParserEXTERNAL)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5542)
			p.Match(PostgreSQLParserSECURITY)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5543)
			p.Match(PostgreSQLParserDEFINER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 8:
		p.EnterOuterAlt(localctx, 8)
		{
			p.SetState(5544)
			p.Match(PostgreSQLParserEXTERNAL)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5545)
			p.Match(PostgreSQLParserSECURITY)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5546)
			p.Match(PostgreSQLParserINVOKER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 9:
		p.EnterOuterAlt(localctx, 9)
		{
			p.SetState(5547)
			p.Match(PostgreSQLParserSECURITY)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5548)
			p.Match(PostgreSQLParserDEFINER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 10:
		p.EnterOuterAlt(localctx, 10)
		{
			p.SetState(5549)
			p.Match(PostgreSQLParserSECURITY)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5550)
			p.Match(PostgreSQLParserINVOKER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 11:
		p.EnterOuterAlt(localctx, 11)
		{
			p.SetState(5551)
			p.Match(PostgreSQLParserLEAKPROOF)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 12:
		p.EnterOuterAlt(localctx, 12)
		{
			p.SetState(5552)
			p.Match(PostgreSQLParserNOT)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5553)
			p.Match(PostgreSQLParserLEAKPROOF)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 13:
		p.EnterOuterAlt(localctx, 13)
		{
			p.SetState(5554)
			p.Match(PostgreSQLParserCOST)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5555)
			p.Numericonly()
		}

	case 14:
		p.EnterOuterAlt(localctx, 14)
		{
			p.SetState(5556)
			p.Match(PostgreSQLParserROWS)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5557)
			p.Numericonly()
		}

	case 15:
		p.EnterOuterAlt(localctx, 15)
		{
			p.SetState(5558)
			p.Match(PostgreSQLParserSUPPORT)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5559)
			p.Any_name()
		}

	case 16:
		p.EnterOuterAlt(localctx, 16)
		{
			p.SetState(5560)
			p.Functionsetresetclause()
		}

	case 17:
		p.EnterOuterAlt(localctx, 17)
		{
			p.SetState(5561)
			p.Match(PostgreSQLParserPARALLEL)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5562)
			p.Colid()
		}

	case antlr.ATNInvalidAltNumber:
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// ICreatefunc_opt_itemContext is an interface to support dynamic dispatch.
type ICreatefunc_opt_itemContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	AS() antlr.TerminalNode
	Func_as() IFunc_asContext
	LANGUAGE() antlr.TerminalNode
	Nonreservedword_or_sconst() INonreservedword_or_sconstContext
	TRANSFORM() antlr.TerminalNode
	Transform_type_list() ITransform_type_listContext
	WINDOW() antlr.TerminalNode
	Common_func_opt_item() ICommon_func_opt_itemContext

	// IsCreatefunc_opt_itemContext differentiates from other interfaces.
	IsCreatefunc_opt_itemContext()
}

type Createfunc_opt_itemContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyCreatefunc_opt_itemContext() *Createfunc_opt_itemContext {
	var p = new(Createfunc_opt_itemContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_createfunc_opt_item
	return p
}

func InitEmptyCreatefunc_opt_itemContext(p *Createfunc_opt_itemContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_createfunc_opt_item
}

func (*Createfunc_opt_itemContext) IsCreatefunc_opt_itemContext() {}

func NewCreatefunc_opt_itemContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Createfunc_opt_itemContext {
	var p = new(Createfunc_opt_itemContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_createfunc_opt_item

	return p
}

func (s *Createfunc_opt_itemContext) GetParser() antlr.Parser { return s.parser }

func (s *Createfunc_opt_itemContext) AS() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserAS, 0)
}

func (s *Createfunc_opt_itemContext) Func_as() IFunc_asContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IFunc_asContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IFunc_asContext)
}

func (s *Createfunc_opt_itemContext) LANGUAGE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserLANGUAGE, 0)
}

func (s *Createfunc_opt_itemContext) Nonreservedword_or_sconst() INonreservedword_or_sconstContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(INonreservedword_or_sconstContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(INonreservedword_or_sconstContext)
}

func (s *Createfunc_opt_itemContext) TRANSFORM() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserTRANSFORM, 0)
}

func (s *Createfunc_opt_itemContext) Transform_type_list() ITransform_type_listContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ITransform_type_listContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ITransform_type_listContext)
}

func (s *Createfunc_opt_itemContext) WINDOW() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserWINDOW, 0)
}

func (s *Createfunc_opt_itemContext) Common_func_opt_item() ICommon_func_opt_itemContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ICommon_func_opt_itemContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ICommon_func_opt_itemContext)
}

func (s *Createfunc_opt_itemContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Createfunc_opt_itemContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Createfunc_opt_itemContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterCreatefunc_opt_item(s)
	}
}

func (s *Createfunc_opt_itemContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitCreatefunc_opt_item(s)
	}
}

func (s *Createfunc_opt_itemContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitCreatefunc_opt_item(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Createfunc_opt_item() (localctx ICreatefunc_opt_itemContext) {
	localctx = NewCreatefunc_opt_itemContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 658, PostgreSQLParserRULE_createfunc_opt_item)
	p.SetState(5573)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetTokenStream().LA(1) {
	case PostgreSQLParserAS:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(5565)
			p.Match(PostgreSQLParserAS)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5566)
			p.Func_as()
		}

	case PostgreSQLParserLANGUAGE:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(5567)
			p.Match(PostgreSQLParserLANGUAGE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5568)
			p.Nonreservedword_or_sconst()
		}

	case PostgreSQLParserTRANSFORM:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(5569)
			p.Match(PostgreSQLParserTRANSFORM)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5570)
			p.Transform_type_list()
		}

	case PostgreSQLParserWINDOW:
		p.EnterOuterAlt(localctx, 4)
		{
			p.SetState(5571)
			p.Match(PostgreSQLParserWINDOW)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case PostgreSQLParserNOT, PostgreSQLParserCALLED, PostgreSQLParserCOST, PostgreSQLParserEXTERNAL, PostgreSQLParserIMMUTABLE, PostgreSQLParserLEAKPROOF, PostgreSQLParserRESET, PostgreSQLParserRETURNS, PostgreSQLParserROWS, PostgreSQLParserSECURITY, PostgreSQLParserSET, PostgreSQLParserSTABLE, PostgreSQLParserSTRICT_P, PostgreSQLParserVOLATILE, PostgreSQLParserSUPPORT, PostgreSQLParserPARALLEL:
		p.EnterOuterAlt(localctx, 5)
		{
			p.SetState(5572)
			p.Common_func_opt_item()
		}

	default:
		p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IFunc_asContext is an interface to support dynamic dispatch.
type IFunc_asContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetDef returns the def rule contexts.
	GetDef() ISconstContext

	// SetDef sets the def rule contexts.
	SetDef(ISconstContext)

	// GetDefinition returns the Definition attribute.
	GetDefinition() antlr.ParserRuleContext

	// SetDefinition sets the Definition attribute.
	SetDefinition(antlr.ParserRuleContext)

	// Getter signatures
	AllSconst() []ISconstContext
	Sconst(i int) ISconstContext
	COMMA() antlr.TerminalNode

	// IsFunc_asContext differentiates from other interfaces.
	IsFunc_asContext()
}

type Func_asContext struct {
	antlr.BaseParserRuleContext
	parser     antlr.Parser
	Definition antlr.ParserRuleContext
	def        ISconstContext
}

func NewEmptyFunc_asContext() *Func_asContext {
	var p = new(Func_asContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_func_as
	return p
}

func InitEmptyFunc_asContext(p *Func_asContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_func_as
}

func (*Func_asContext) IsFunc_asContext() {}

func NewFunc_asContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Func_asContext {
	var p = new(Func_asContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_func_as

	return p
}

func (s *Func_asContext) GetParser() antlr.Parser { return s.parser }

func (s *Func_asContext) GetDef() ISconstContext { return s.def }

func (s *Func_asContext) SetDef(v ISconstContext) { s.def = v }

func (s *Func_asContext) GetDefinition() antlr.ParserRuleContext { return s.Definition }

func (s *Func_asContext) SetDefinition(v antlr.ParserRuleContext) { s.Definition = v }

func (s *Func_asContext) AllSconst() []ISconstContext {
	children := s.GetChildren()
	len := 0
	for _, ctx := range children {
		if _, ok := ctx.(ISconstContext); ok {
			len++
		}
	}

	tst := make([]ISconstContext, len)
	i := 0
	for _, ctx := range children {
		if t, ok := ctx.(ISconstContext); ok {
			tst[i] = t.(ISconstContext)
			i++
		}
	}

	return tst
}

func (s *Func_asContext) Sconst(i int) ISconstContext {
	var t antlr.RuleContext
	j := 0
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ISconstContext); ok {
			if j == i {
				t = ctx.(antlr.RuleContext)
				break
			}
			j++
		}
	}

	if t == nil {
		return nil
	}

	return t.(ISconstContext)
}

func (s *Func_asContext) COMMA() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCOMMA, 0)
}

func (s *Func_asContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Func_asContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Func_asContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterFunc_as(s)
	}
}

func (s *Func_asContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitFunc_as(s)
	}
}

func (s *Func_asContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitFunc_as(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Func_as() (localctx IFunc_asContext) {
	localctx = NewFunc_asContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 660, PostgreSQLParserRULE_func_as)
	p.SetState(5580)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 289, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(5575)

			var _x = p.Sconst()

			localctx.(*Func_asContext).def = _x
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(5576)
			p.Sconst()
		}
		{
			p.SetState(5577)
			p.Match(PostgreSQLParserCOMMA)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5578)
			p.Sconst()
		}

	case antlr.ATNInvalidAltNumber:
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// ITransform_type_listContext is an interface to support dynamic dispatch.
type ITransform_type_listContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	AllFOR() []antlr.TerminalNode
	FOR(i int) antlr.TerminalNode
	AllTYPE_P() []antlr.TerminalNode
	TYPE_P(i int) antlr.TerminalNode
	AllTypename() []ITypenameContext
	Typename(i int) ITypenameContext
	AllCOMMA() []antlr.TerminalNode
	COMMA(i int) antlr.TerminalNode

	// IsTransform_type_listContext differentiates from other interfaces.
	IsTransform_type_listContext()
}

type Transform_type_listContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyTransform_type_listContext() *Transform_type_listContext {
	var p = new(Transform_type_listContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_transform_type_list
	return p
}

func InitEmptyTransform_type_listContext(p *Transform_type_listContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_transform_type_list
}

func (*Transform_type_listContext) IsTransform_type_listContext() {}

func NewTransform_type_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Transform_type_listContext {
	var p = new(Transform_type_listContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_transform_type_list

	return p
}

func (s *Transform_type_listContext) GetParser() antlr.Parser { return s.parser }

func (s *Transform_type_listContext) AllFOR() []antlr.TerminalNode {
	return s.GetTokens(PostgreSQLParserFOR)
}

func (s *Transform_type_listContext) FOR(i int) antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserFOR, i)
}

func (s *Transform_type_listContext) AllTYPE_P() []antlr.TerminalNode {
	return s.GetTokens(PostgreSQLParserTYPE_P)
}

func (s *Transform_type_listContext) TYPE_P(i int) antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserTYPE_P, i)
}

func (s *Transform_type_listContext) AllTypename() []ITypenameContext {
	children := s.GetChildren()
	len := 0
	for _, ctx := range children {
		if _, ok := ctx.(ITypenameContext); ok {
			len++
		}
	}

	tst := make([]ITypenameContext, len)
	i := 0
	for _, ctx := range children {
		if t, ok := ctx.(ITypenameContext); ok {
			tst[i] = t.(ITypenameContext)
			i++
		}
	}

	return tst
}

func (s *Transform_type_listContext) Typename(i int) ITypenameContext {
	var t antlr.RuleContext
	j := 0
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ITypenameContext); ok {
			if j == i {
				t = ctx.(antlr.RuleContext)
				break
			}
			j++
		}
	}

	if t == nil {
		return nil
	}

	return t.(ITypenameContext)
}

func (s *Transform_type_listContext) AllCOMMA() []antlr.TerminalNode {
	return s.GetTokens(PostgreSQLParserCOMMA)
}

func (s *Transform_type_listContext) COMMA(i int) antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCOMMA, i)
}

func (s *Transform_type_listContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Transform_type_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Transform_type_listContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterTransform_type_list(s)
	}
}

func (s *Transform_type_listContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitTransform_type_list(s)
	}
}

func (s *Transform_type_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitTransform_type_list(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Transform_type_list() (localctx ITransform_type_listContext) {
	localctx = NewTransform_type_listContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 662, PostgreSQLParserRULE_transform_type_list)
	var _la int

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(5582)
		p.Match(PostgreSQLParserFOR)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(5583)
		p.Match(PostgreSQLParserTYPE_P)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(5584)
		p.Typename()
	}
	p.SetState(5591)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}
	_la = p.GetTokenStream().LA(1)

	for _la == PostgreSQLParserCOMMA {
		{
			p.SetState(5585)
			p.Match(PostgreSQLParserCOMMA)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5586)
			p.Match(PostgreSQLParserFOR)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5587)
			p.Match(PostgreSQLParserTYPE_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5588)
			p.Typename()
		}

		p.SetState(5593)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}
		_la = p.GetTokenStream().LA(1)
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IOpt_definitionContext is an interface to support dynamic dispatch.
type IOpt_definitionContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	WITH() antlr.TerminalNode
	Definition() IDefinitionContext

	// IsOpt_definitionContext differentiates from other interfaces.
	IsOpt_definitionContext()
}

type Opt_definitionContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyOpt_definitionContext() *Opt_definitionContext {
	var p = new(Opt_definitionContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opt_definition
	return p
}

func InitEmptyOpt_definitionContext(p *Opt_definitionContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opt_definition
}

func (*Opt_definitionContext) IsOpt_definitionContext() {}

func NewOpt_definitionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_definitionContext {
	var p = new(Opt_definitionContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_opt_definition

	return p
}

func (s *Opt_definitionContext) GetParser() antlr.Parser { return s.parser }

func (s *Opt_definitionContext) WITH() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserWITH, 0)
}

func (s *Opt_definitionContext) Definition() IDefinitionContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IDefinitionContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IDefinitionContext)
}

func (s *Opt_definitionContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Opt_definitionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Opt_definitionContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterOpt_definition(s)
	}
}

func (s *Opt_definitionContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitOpt_definition(s)
	}
}

func (s *Opt_definitionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitOpt_definition(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Opt_definition() (localctx IOpt_definitionContext) {
	localctx = NewOpt_definitionContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 664, PostgreSQLParserRULE_opt_definition)
	p.SetState(5597)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 291, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(5594)
			p.Match(PostgreSQLParserWITH)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5595)
			p.Definition()
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)

	case antlr.ATNInvalidAltNumber:
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// ITable_func_columnContext is an interface to support dynamic dispatch.
type ITable_func_columnContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Param_name() IParam_nameContext
	Func_type() IFunc_typeContext

	// IsTable_func_columnContext differentiates from other interfaces.
	IsTable_func_columnContext()
}

type Table_func_columnContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyTable_func_columnContext() *Table_func_columnContext {
	var p = new(Table_func_columnContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_table_func_column
	return p
}

func InitEmptyTable_func_columnContext(p *Table_func_columnContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_table_func_column
}

func (*Table_func_columnContext) IsTable_func_columnContext() {}

func NewTable_func_columnContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Table_func_columnContext {
	var p = new(Table_func_columnContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_table_func_column

	return p
}

func (s *Table_func_columnContext) GetParser() antlr.Parser { return s.parser }

func (s *Table_func_columnContext) Param_name() IParam_nameContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IParam_nameContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IParam_nameContext)
}

func (s *Table_func_columnContext) Func_type() IFunc_typeContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IFunc_typeContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IFunc_typeContext)
}

func (s *Table_func_columnContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Table_func_columnContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Table_func_columnContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterTable_func_column(s)
	}
}

func (s *Table_func_columnContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitTable_func_column(s)
	}
}

func (s *Table_func_columnContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitTable_func_column(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Table_func_column() (localctx ITable_func_columnContext) {
	localctx = NewTable_func_columnContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 666, PostgreSQLParserRULE_table_func_column)
	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(5599)
		p.Param_name()
	}
	{
		p.SetState(5600)
		p.Func_type()
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// ITable_func_column_listContext is an interface to support dynamic dispatch.
type ITable_func_column_listContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	AllTable_func_column() []ITable_func_columnContext
	Table_func_column(i int) ITable_func_columnContext
	AllCOMMA() []antlr.TerminalNode
	COMMA(i int) antlr.TerminalNode

	// IsTable_func_column_listContext differentiates from other interfaces.
	IsTable_func_column_listContext()
}

type Table_func_column_listContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyTable_func_column_listContext() *Table_func_column_listContext {
	var p = new(Table_func_column_listContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_table_func_column_list
	return p
}

func InitEmptyTable_func_column_listContext(p *Table_func_column_listContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_table_func_column_list
}

func (*Table_func_column_listContext) IsTable_func_column_listContext() {}

func NewTable_func_column_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Table_func_column_listContext {
	var p = new(Table_func_column_listContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_table_func_column_list

	return p
}

func (s *Table_func_column_listContext) GetParser() antlr.Parser { return s.parser }

func (s *Table_func_column_listContext) AllTable_func_column() []ITable_func_columnContext {
	children := s.GetChildren()
	len := 0
	for _, ctx := range children {
		if _, ok := ctx.(ITable_func_columnContext); ok {
			len++
		}
	}

	tst := make([]ITable_func_columnContext, len)
	i := 0
	for _, ctx := range children {
		if t, ok := ctx.(ITable_func_columnContext); ok {
			tst[i] = t.(ITable_func_columnContext)
			i++
		}
	}

	return tst
}

func (s *Table_func_column_listContext) Table_func_column(i int) ITable_func_columnContext {
	var t antlr.RuleContext
	j := 0
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ITable_func_columnContext); ok {
			if j == i {
				t = ctx.(antlr.RuleContext)
				break
			}
			j++
		}
	}

	if t == nil {
		return nil
	}

	return t.(ITable_func_columnContext)
}

func (s *Table_func_column_listContext) AllCOMMA() []antlr.TerminalNode {
	return s.GetTokens(PostgreSQLParserCOMMA)
}

func (s *Table_func_column_listContext) COMMA(i int) antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCOMMA, i)
}

func (s *Table_func_column_listContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Table_func_column_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Table_func_column_listContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterTable_func_column_list(s)
	}
}

func (s *Table_func_column_listContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitTable_func_column_list(s)
	}
}

func (s *Table_func_column_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitTable_func_column_list(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Table_func_column_list() (localctx ITable_func_column_listContext) {
	localctx = NewTable_func_column_listContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 668, PostgreSQLParserRULE_table_func_column_list)
	var _la int

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(5602)
		p.Table_func_column()
	}
	p.SetState(5607)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}
	_la = p.GetTokenStream().LA(1)

	for _la == PostgreSQLParserCOMMA {
		{
			p.SetState(5603)
			p.Match(PostgreSQLParserCOMMA)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5604)
			p.Table_func_column()
		}

		p.SetState(5609)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}
		_la = p.GetTokenStream().LA(1)
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IAlterfunctionstmtContext is an interface to support dynamic dispatch.
type IAlterfunctionstmtContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	ALTER() antlr.TerminalNode
	Function_with_argtypes() IFunction_with_argtypesContext
	Alterfunc_opt_list() IAlterfunc_opt_listContext
	Opt_restrict() IOpt_restrictContext
	FUNCTION() antlr.TerminalNode
	PROCEDURE() antlr.TerminalNode
	ROUTINE() antlr.TerminalNode

	// IsAlterfunctionstmtContext differentiates from other interfaces.
	IsAlterfunctionstmtContext()
}

type AlterfunctionstmtContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyAlterfunctionstmtContext() *AlterfunctionstmtContext {
	var p = new(AlterfunctionstmtContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_alterfunctionstmt
	return p
}

func InitEmptyAlterfunctionstmtContext(p *AlterfunctionstmtContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_alterfunctionstmt
}

func (*AlterfunctionstmtContext) IsAlterfunctionstmtContext() {}

func NewAlterfunctionstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AlterfunctionstmtContext {
	var p = new(AlterfunctionstmtContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_alterfunctionstmt

	return p
}

func (s *AlterfunctionstmtContext) GetParser() antlr.Parser { return s.parser }

func (s *AlterfunctionstmtContext) ALTER() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserALTER, 0)
}

func (s *AlterfunctionstmtContext) Function_with_argtypes() IFunction_with_argtypesContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IFunction_with_argtypesContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IFunction_with_argtypesContext)
}

func (s *AlterfunctionstmtContext) Alterfunc_opt_list() IAlterfunc_opt_listContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IAlterfunc_opt_listContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IAlterfunc_opt_listContext)
}

func (s *AlterfunctionstmtContext) Opt_restrict() IOpt_restrictContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOpt_restrictContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOpt_restrictContext)
}

func (s *AlterfunctionstmtContext) FUNCTION() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserFUNCTION, 0)
}

func (s *AlterfunctionstmtContext) PROCEDURE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserPROCEDURE, 0)
}

func (s *AlterfunctionstmtContext) ROUTINE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserROUTINE, 0)
}

func (s *AlterfunctionstmtContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *AlterfunctionstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *AlterfunctionstmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterAlterfunctionstmt(s)
	}
}

func (s *AlterfunctionstmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitAlterfunctionstmt(s)
	}
}

func (s *AlterfunctionstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitAlterfunctionstmt(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Alterfunctionstmt() (localctx IAlterfunctionstmtContext) {
	localctx = NewAlterfunctionstmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 670, PostgreSQLParserRULE_alterfunctionstmt)
	var _la int

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(5610)
		p.Match(PostgreSQLParserALTER)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(5611)
		_la = p.GetTokenStream().LA(1)

		if !(_la == PostgreSQLParserFUNCTION || _la == PostgreSQLParserPROCEDURE || _la == PostgreSQLParserROUTINE) {
			p.GetErrorHandler().RecoverInline(p)
		} else {
			p.GetErrorHandler().ReportMatch(p)
			p.Consume()
		}
	}
	{
		p.SetState(5612)
		p.Function_with_argtypes()
	}
	{
		p.SetState(5613)
		p.Alterfunc_opt_list()
	}
	{
		p.SetState(5614)
		p.Opt_restrict()
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IAlterfunc_opt_listContext is an interface to support dynamic dispatch.
type IAlterfunc_opt_listContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	AllCommon_func_opt_item() []ICommon_func_opt_itemContext
	Common_func_opt_item(i int) ICommon_func_opt_itemContext

	// IsAlterfunc_opt_listContext differentiates from other interfaces.
	IsAlterfunc_opt_listContext()
}

type Alterfunc_opt_listContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyAlterfunc_opt_listContext() *Alterfunc_opt_listContext {
	var p = new(Alterfunc_opt_listContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_alterfunc_opt_list
	return p
}

func InitEmptyAlterfunc_opt_listContext(p *Alterfunc_opt_listContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_alterfunc_opt_list
}

func (*Alterfunc_opt_listContext) IsAlterfunc_opt_listContext() {}

func NewAlterfunc_opt_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alterfunc_opt_listContext {
	var p = new(Alterfunc_opt_listContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_alterfunc_opt_list

	return p
}

func (s *Alterfunc_opt_listContext) GetParser() antlr.Parser { return s.parser }

func (s *Alterfunc_opt_listContext) AllCommon_func_opt_item() []ICommon_func_opt_itemContext {
	children := s.GetChildren()
	len := 0
	for _, ctx := range children {
		if _, ok := ctx.(ICommon_func_opt_itemContext); ok {
			len++
		}
	}

	tst := make([]ICommon_func_opt_itemContext, len)
	i := 0
	for _, ctx := range children {
		if t, ok := ctx.(ICommon_func_opt_itemContext); ok {
			tst[i] = t.(ICommon_func_opt_itemContext)
			i++
		}
	}

	return tst
}

func (s *Alterfunc_opt_listContext) Common_func_opt_item(i int) ICommon_func_opt_itemContext {
	var t antlr.RuleContext
	j := 0
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ICommon_func_opt_itemContext); ok {
			if j == i {
				t = ctx.(antlr.RuleContext)
				break
			}
			j++
		}
	}

	if t == nil {
		return nil
	}

	return t.(ICommon_func_opt_itemContext)
}

func (s *Alterfunc_opt_listContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Alterfunc_opt_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Alterfunc_opt_listContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterAlterfunc_opt_list(s)
	}
}

func (s *Alterfunc_opt_listContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitAlterfunc_opt_list(s)
	}
}

func (s *Alterfunc_opt_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitAlterfunc_opt_list(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Alterfunc_opt_list() (localctx IAlterfunc_opt_listContext) {
	localctx = NewAlterfunc_opt_listContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 672, PostgreSQLParserRULE_alterfunc_opt_list)
	var _alt int

	p.EnterOuterAlt(localctx, 1)
	p.SetState(5617)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}
	_alt = 1
	for ok := true; ok; ok = _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
		switch _alt {
		case 1:
			{
				p.SetState(5616)
				p.Common_func_opt_item()
			}

		default:
			p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
			goto errorExit
		}

		p.SetState(5619)
		p.GetErrorHandler().Sync(p)
		_alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 293, p.GetParserRuleContext())
		if p.HasError() {
			goto errorExit
		}
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IOpt_restrictContext is an interface to support dynamic dispatch.
type IOpt_restrictContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	RESTRICT() antlr.TerminalNode

	// IsOpt_restrictContext differentiates from other interfaces.
	IsOpt_restrictContext()
}

type Opt_restrictContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyOpt_restrictContext() *Opt_restrictContext {
	var p = new(Opt_restrictContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opt_restrict
	return p
}

func InitEmptyOpt_restrictContext(p *Opt_restrictContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opt_restrict
}

func (*Opt_restrictContext) IsOpt_restrictContext() {}

func NewOpt_restrictContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_restrictContext {
	var p = new(Opt_restrictContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_opt_restrict

	return p
}

func (s *Opt_restrictContext) GetParser() antlr.Parser { return s.parser }

func (s *Opt_restrictContext) RESTRICT() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserRESTRICT, 0)
}

func (s *Opt_restrictContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Opt_restrictContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Opt_restrictContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterOpt_restrict(s)
	}
}

func (s *Opt_restrictContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitOpt_restrict(s)
	}
}

func (s *Opt_restrictContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitOpt_restrict(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Opt_restrict() (localctx IOpt_restrictContext) {
	localctx = NewOpt_restrictContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 674, PostgreSQLParserRULE_opt_restrict)
	p.SetState(5623)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetTokenStream().LA(1) {
	case PostgreSQLParserRESTRICT:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(5621)
			p.Match(PostgreSQLParserRESTRICT)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case PostgreSQLParserEOF, PostgreSQLParserOPEN_PAREN, PostgreSQLParserSEMI, PostgreSQLParserANALYSE, PostgreSQLParserANALYZE, PostgreSQLParserCREATE, PostgreSQLParserDO, PostgreSQLParserFETCH, PostgreSQLParserGRANT, PostgreSQLParserINTO, PostgreSQLParserSELECT, PostgreSQLParserTABLE, PostgreSQLParserWITH, PostgreSQLParserABORT_P, PostgreSQLParserALTER, PostgreSQLParserBEGIN_P, PostgreSQLParserCHECKPOINT, PostgreSQLParserCLOSE, PostgreSQLParserCLUSTER, PostgreSQLParserCOMMENT, PostgreSQLParserCOMMIT, PostgreSQLParserCOPY, PostgreSQLParserDEALLOCATE, PostgreSQLParserDECLARE, PostgreSQLParserDELETE_P, PostgreSQLParserDISCARD, PostgreSQLParserDROP, PostgreSQLParserEXECUTE, PostgreSQLParserEXPLAIN, PostgreSQLParserINSERT, PostgreSQLParserLISTEN, PostgreSQLParserLOAD, PostgreSQLParserLOCK_P, PostgreSQLParserMERGE, PostgreSQLParserMOVE, PostgreSQLParserNOTIFY, PostgreSQLParserPREPARE, PostgreSQLParserREASSIGN, PostgreSQLParserREFRESH, PostgreSQLParserREINDEX, PostgreSQLParserRELEASE, PostgreSQLParserRESET, PostgreSQLParserREVOKE, PostgreSQLParserROLLBACK, PostgreSQLParserSAVEPOINT, PostgreSQLParserSECURITY, PostgreSQLParserSET, PostgreSQLParserSHOW, PostgreSQLParserSTART, PostgreSQLParserTRUNCATE, PostgreSQLParserUNLISTEN, PostgreSQLParserUPDATE, PostgreSQLParserVACUUM, PostgreSQLParserVALUES, PostgreSQLParserCALL, PostgreSQLParserIMPORT_P, PostgreSQLParserEND_P, PostgreSQLParserMetaCommand:
		p.EnterOuterAlt(localctx, 2)

	default:
		p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IRemovefuncstmtContext is an interface to support dynamic dispatch.
type IRemovefuncstmtContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	DROP() antlr.TerminalNode
	FUNCTION() antlr.TerminalNode
	Function_with_argtypes_list() IFunction_with_argtypes_listContext
	Opt_drop_behavior() IOpt_drop_behaviorContext
	IF_P() antlr.TerminalNode
	EXISTS() antlr.TerminalNode
	PROCEDURE() antlr.TerminalNode
	ROUTINE() antlr.TerminalNode

	// IsRemovefuncstmtContext differentiates from other interfaces.
	IsRemovefuncstmtContext()
}

type RemovefuncstmtContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyRemovefuncstmtContext() *RemovefuncstmtContext {
	var p = new(RemovefuncstmtContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_removefuncstmt
	return p
}

func InitEmptyRemovefuncstmtContext(p *RemovefuncstmtContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_removefuncstmt
}

func (*RemovefuncstmtContext) IsRemovefuncstmtContext() {}

func NewRemovefuncstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *RemovefuncstmtContext {
	var p = new(RemovefuncstmtContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_removefuncstmt

	return p
}

func (s *RemovefuncstmtContext) GetParser() antlr.Parser { return s.parser }

func (s *RemovefuncstmtContext) DROP() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserDROP, 0)
}

func (s *RemovefuncstmtContext) FUNCTION() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserFUNCTION, 0)
}

func (s *RemovefuncstmtContext) Function_with_argtypes_list() IFunction_with_argtypes_listContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IFunction_with_argtypes_listContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IFunction_with_argtypes_listContext)
}

func (s *RemovefuncstmtContext) Opt_drop_behavior() IOpt_drop_behaviorContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOpt_drop_behaviorContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOpt_drop_behaviorContext)
}

func (s *RemovefuncstmtContext) IF_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserIF_P, 0)
}

func (s *RemovefuncstmtContext) EXISTS() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserEXISTS, 0)
}

func (s *RemovefuncstmtContext) PROCEDURE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserPROCEDURE, 0)
}

func (s *RemovefuncstmtContext) ROUTINE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserROUTINE, 0)
}

func (s *RemovefuncstmtContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *RemovefuncstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *RemovefuncstmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterRemovefuncstmt(s)
	}
}

func (s *RemovefuncstmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitRemovefuncstmt(s)
	}
}

func (s *RemovefuncstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitRemovefuncstmt(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Removefuncstmt() (localctx IRemovefuncstmtContext) {
	localctx = NewRemovefuncstmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 676, PostgreSQLParserRULE_removefuncstmt)
	p.SetState(5661)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 295, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(5625)
			p.Match(PostgreSQLParserDROP)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5626)
			p.Match(PostgreSQLParserFUNCTION)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5627)
			p.Function_with_argtypes_list()
		}
		{
			p.SetState(5628)
			p.Opt_drop_behavior()
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(5630)
			p.Match(PostgreSQLParserDROP)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5631)
			p.Match(PostgreSQLParserFUNCTION)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5632)
			p.Match(PostgreSQLParserIF_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5633)
			p.Match(PostgreSQLParserEXISTS)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5634)
			p.Function_with_argtypes_list()
		}
		{
			p.SetState(5635)
			p.Opt_drop_behavior()
		}

	case 3:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(5637)
			p.Match(PostgreSQLParserDROP)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5638)
			p.Match(PostgreSQLParserPROCEDURE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5639)
			p.Function_with_argtypes_list()
		}
		{
			p.SetState(5640)
			p.Opt_drop_behavior()
		}

	case 4:
		p.EnterOuterAlt(localctx, 4)
		{
			p.SetState(5642)
			p.Match(PostgreSQLParserDROP)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5643)
			p.Match(PostgreSQLParserPROCEDURE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5644)
			p.Match(PostgreSQLParserIF_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5645)
			p.Match(PostgreSQLParserEXISTS)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5646)
			p.Function_with_argtypes_list()
		}
		{
			p.SetState(5647)
			p.Opt_drop_behavior()
		}

	case 5:
		p.EnterOuterAlt(localctx, 5)
		{
			p.SetState(5649)
			p.Match(PostgreSQLParserDROP)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5650)
			p.Match(PostgreSQLParserROUTINE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5651)
			p.Function_with_argtypes_list()
		}
		{
			p.SetState(5652)
			p.Opt_drop_behavior()
		}

	case 6:
		p.EnterOuterAlt(localctx, 6)
		{
			p.SetState(5654)
			p.Match(PostgreSQLParserDROP)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5655)
			p.Match(PostgreSQLParserROUTINE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5656)
			p.Match(PostgreSQLParserIF_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5657)
			p.Match(PostgreSQLParserEXISTS)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5658)
			p.Function_with_argtypes_list()
		}
		{
			p.SetState(5659)
			p.Opt_drop_behavior()
		}

	case antlr.ATNInvalidAltNumber:
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IRemoveaggrstmtContext is an interface to support dynamic dispatch.
type IRemoveaggrstmtContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	DROP() antlr.TerminalNode
	AGGREGATE() antlr.TerminalNode
	Aggregate_with_argtypes_list() IAggregate_with_argtypes_listContext
	Opt_drop_behavior() IOpt_drop_behaviorContext
	IF_P() antlr.TerminalNode
	EXISTS() antlr.TerminalNode

	// IsRemoveaggrstmtContext differentiates from other interfaces.
	IsRemoveaggrstmtContext()
}

type RemoveaggrstmtContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyRemoveaggrstmtContext() *RemoveaggrstmtContext {
	var p = new(RemoveaggrstmtContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_removeaggrstmt
	return p
}

func InitEmptyRemoveaggrstmtContext(p *RemoveaggrstmtContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_removeaggrstmt
}

func (*RemoveaggrstmtContext) IsRemoveaggrstmtContext() {}

func NewRemoveaggrstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *RemoveaggrstmtContext {
	var p = new(RemoveaggrstmtContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_removeaggrstmt

	return p
}

func (s *RemoveaggrstmtContext) GetParser() antlr.Parser { return s.parser }

func (s *RemoveaggrstmtContext) DROP() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserDROP, 0)
}

func (s *RemoveaggrstmtContext) AGGREGATE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserAGGREGATE, 0)
}

func (s *RemoveaggrstmtContext) Aggregate_with_argtypes_list() IAggregate_with_argtypes_listContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IAggregate_with_argtypes_listContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IAggregate_with_argtypes_listContext)
}

func (s *RemoveaggrstmtContext) Opt_drop_behavior() IOpt_drop_behaviorContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOpt_drop_behaviorContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOpt_drop_behaviorContext)
}

func (s *RemoveaggrstmtContext) IF_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserIF_P, 0)
}

func (s *RemoveaggrstmtContext) EXISTS() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserEXISTS, 0)
}

func (s *RemoveaggrstmtContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *RemoveaggrstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *RemoveaggrstmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterRemoveaggrstmt(s)
	}
}

func (s *RemoveaggrstmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitRemoveaggrstmt(s)
	}
}

func (s *RemoveaggrstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitRemoveaggrstmt(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Removeaggrstmt() (localctx IRemoveaggrstmtContext) {
	localctx = NewRemoveaggrstmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 678, PostgreSQLParserRULE_removeaggrstmt)
	p.SetState(5675)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 296, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(5663)
			p.Match(PostgreSQLParserDROP)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5664)
			p.Match(PostgreSQLParserAGGREGATE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5665)
			p.Aggregate_with_argtypes_list()
		}
		{
			p.SetState(5666)
			p.Opt_drop_behavior()
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(5668)
			p.Match(PostgreSQLParserDROP)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5669)
			p.Match(PostgreSQLParserAGGREGATE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5670)
			p.Match(PostgreSQLParserIF_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5671)
			p.Match(PostgreSQLParserEXISTS)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5672)
			p.Aggregate_with_argtypes_list()
		}
		{
			p.SetState(5673)
			p.Opt_drop_behavior()
		}

	case antlr.ATNInvalidAltNumber:
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IRemoveoperstmtContext is an interface to support dynamic dispatch.
type IRemoveoperstmtContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	DROP() antlr.TerminalNode
	OPERATOR() antlr.TerminalNode
	Operator_with_argtypes_list() IOperator_with_argtypes_listContext
	Opt_drop_behavior() IOpt_drop_behaviorContext
	IF_P() antlr.TerminalNode
	EXISTS() antlr.TerminalNode

	// IsRemoveoperstmtContext differentiates from other interfaces.
	IsRemoveoperstmtContext()
}

type RemoveoperstmtContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyRemoveoperstmtContext() *RemoveoperstmtContext {
	var p = new(RemoveoperstmtContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_removeoperstmt
	return p
}

func InitEmptyRemoveoperstmtContext(p *RemoveoperstmtContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_removeoperstmt
}

func (*RemoveoperstmtContext) IsRemoveoperstmtContext() {}

func NewRemoveoperstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *RemoveoperstmtContext {
	var p = new(RemoveoperstmtContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_removeoperstmt

	return p
}

func (s *RemoveoperstmtContext) GetParser() antlr.Parser { return s.parser }

func (s *RemoveoperstmtContext) DROP() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserDROP, 0)
}

func (s *RemoveoperstmtContext) OPERATOR() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserOPERATOR, 0)
}

func (s *RemoveoperstmtContext) Operator_with_argtypes_list() IOperator_with_argtypes_listContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOperator_with_argtypes_listContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOperator_with_argtypes_listContext)
}

func (s *RemoveoperstmtContext) Opt_drop_behavior() IOpt_drop_behaviorContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOpt_drop_behaviorContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOpt_drop_behaviorContext)
}

func (s *RemoveoperstmtContext) IF_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserIF_P, 0)
}

func (s *RemoveoperstmtContext) EXISTS() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserEXISTS, 0)
}

func (s *RemoveoperstmtContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *RemoveoperstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *RemoveoperstmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterRemoveoperstmt(s)
	}
}

func (s *RemoveoperstmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitRemoveoperstmt(s)
	}
}

func (s *RemoveoperstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitRemoveoperstmt(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Removeoperstmt() (localctx IRemoveoperstmtContext) {
	localctx = NewRemoveoperstmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 680, PostgreSQLParserRULE_removeoperstmt)
	p.SetState(5689)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 297, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(5677)
			p.Match(PostgreSQLParserDROP)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5678)
			p.Match(PostgreSQLParserOPERATOR)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5679)
			p.Operator_with_argtypes_list()
		}
		{
			p.SetState(5680)
			p.Opt_drop_behavior()
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(5682)
			p.Match(PostgreSQLParserDROP)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5683)
			p.Match(PostgreSQLParserOPERATOR)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5684)
			p.Match(PostgreSQLParserIF_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5685)
			p.Match(PostgreSQLParserEXISTS)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5686)
			p.Operator_with_argtypes_list()
		}
		{
			p.SetState(5687)
			p.Opt_drop_behavior()
		}

	case antlr.ATNInvalidAltNumber:
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IOper_argtypesContext is an interface to support dynamic dispatch.
type IOper_argtypesContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	OPEN_PAREN() antlr.TerminalNode
	AllTypename() []ITypenameContext
	Typename(i int) ITypenameContext
	CLOSE_PAREN() antlr.TerminalNode
	COMMA() antlr.TerminalNode
	NONE() antlr.TerminalNode

	// IsOper_argtypesContext differentiates from other interfaces.
	IsOper_argtypesContext()
}

type Oper_argtypesContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyOper_argtypesContext() *Oper_argtypesContext {
	var p = new(Oper_argtypesContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_oper_argtypes
	return p
}

func InitEmptyOper_argtypesContext(p *Oper_argtypesContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_oper_argtypes
}

func (*Oper_argtypesContext) IsOper_argtypesContext() {}

func NewOper_argtypesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Oper_argtypesContext {
	var p = new(Oper_argtypesContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_oper_argtypes

	return p
}

func (s *Oper_argtypesContext) GetParser() antlr.Parser { return s.parser }

func (s *Oper_argtypesContext) OPEN_PAREN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserOPEN_PAREN, 0)
}

func (s *Oper_argtypesContext) AllTypename() []ITypenameContext {
	children := s.GetChildren()
	len := 0
	for _, ctx := range children {
		if _, ok := ctx.(ITypenameContext); ok {
			len++
		}
	}

	tst := make([]ITypenameContext, len)
	i := 0
	for _, ctx := range children {
		if t, ok := ctx.(ITypenameContext); ok {
			tst[i] = t.(ITypenameContext)
			i++
		}
	}

	return tst
}

func (s *Oper_argtypesContext) Typename(i int) ITypenameContext {
	var t antlr.RuleContext
	j := 0
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ITypenameContext); ok {
			if j == i {
				t = ctx.(antlr.RuleContext)
				break
			}
			j++
		}
	}

	if t == nil {
		return nil
	}

	return t.(ITypenameContext)
}

func (s *Oper_argtypesContext) CLOSE_PAREN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCLOSE_PAREN, 0)
}

func (s *Oper_argtypesContext) COMMA() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCOMMA, 0)
}

func (s *Oper_argtypesContext) NONE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserNONE, 0)
}

func (s *Oper_argtypesContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Oper_argtypesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Oper_argtypesContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterOper_argtypes(s)
	}
}

func (s *Oper_argtypesContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitOper_argtypes(s)
	}
}

func (s *Oper_argtypesContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitOper_argtypes(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Oper_argtypes() (localctx IOper_argtypesContext) {
	localctx = NewOper_argtypesContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 682, PostgreSQLParserRULE_oper_argtypes)
	p.SetState(5713)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 298, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(5691)
			p.Match(PostgreSQLParserOPEN_PAREN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5692)
			p.Typename()
		}
		{
			p.SetState(5693)
			p.Match(PostgreSQLParserCLOSE_PAREN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(5695)
			p.Match(PostgreSQLParserOPEN_PAREN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5696)
			p.Typename()
		}
		{
			p.SetState(5697)
			p.Match(PostgreSQLParserCOMMA)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5698)
			p.Typename()
		}
		{
			p.SetState(5699)
			p.Match(PostgreSQLParserCLOSE_PAREN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 3:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(5701)
			p.Match(PostgreSQLParserOPEN_PAREN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5702)
			p.Match(PostgreSQLParserNONE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5703)
			p.Match(PostgreSQLParserCOMMA)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5704)
			p.Typename()
		}
		{
			p.SetState(5705)
			p.Match(PostgreSQLParserCLOSE_PAREN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 4:
		p.EnterOuterAlt(localctx, 4)
		{
			p.SetState(5707)
			p.Match(PostgreSQLParserOPEN_PAREN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5708)
			p.Typename()
		}
		{
			p.SetState(5709)
			p.Match(PostgreSQLParserCOMMA)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5710)
			p.Match(PostgreSQLParserNONE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5711)
			p.Match(PostgreSQLParserCLOSE_PAREN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case antlr.ATNInvalidAltNumber:
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IAny_operatorContext is an interface to support dynamic dispatch.
type IAny_operatorContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	All_op() IAll_opContext
	AllColid() []IColidContext
	Colid(i int) IColidContext
	AllDOT() []antlr.TerminalNode
	DOT(i int) antlr.TerminalNode

	// IsAny_operatorContext differentiates from other interfaces.
	IsAny_operatorContext()
}

type Any_operatorContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyAny_operatorContext() *Any_operatorContext {
	var p = new(Any_operatorContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_any_operator
	return p
}

func InitEmptyAny_operatorContext(p *Any_operatorContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_any_operator
}

func (*Any_operatorContext) IsAny_operatorContext() {}

func NewAny_operatorContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Any_operatorContext {
	var p = new(Any_operatorContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_any_operator

	return p
}

func (s *Any_operatorContext) GetParser() antlr.Parser { return s.parser }

func (s *Any_operatorContext) All_op() IAll_opContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IAll_opContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IAll_opContext)
}

func (s *Any_operatorContext) AllColid() []IColidContext {
	children := s.GetChildren()
	len := 0
	for _, ctx := range children {
		if _, ok := ctx.(IColidContext); ok {
			len++
		}
	}

	tst := make([]IColidContext, len)
	i := 0
	for _, ctx := range children {
		if t, ok := ctx.(IColidContext); ok {
			tst[i] = t.(IColidContext)
			i++
		}
	}

	return tst
}

func (s *Any_operatorContext) Colid(i int) IColidContext {
	var t antlr.RuleContext
	j := 0
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IColidContext); ok {
			if j == i {
				t = ctx.(antlr.RuleContext)
				break
			}
			j++
		}
	}

	if t == nil {
		return nil
	}

	return t.(IColidContext)
}

func (s *Any_operatorContext) AllDOT() []antlr.TerminalNode {
	return s.GetTokens(PostgreSQLParserDOT)
}

func (s *Any_operatorContext) DOT(i int) antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserDOT, i)
}

func (s *Any_operatorContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Any_operatorContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Any_operatorContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterAny_operator(s)
	}
}

func (s *Any_operatorContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitAny_operator(s)
	}
}

func (s *Any_operatorContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitAny_operator(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Any_operator() (localctx IAny_operatorContext) {
	localctx = NewAny_operatorContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 684, PostgreSQLParserRULE_any_operator)
	var _la int

	p.EnterOuterAlt(localctx, 1)
	p.SetState(5720)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}
	_la = p.GetTokenStream().LA(1)

	for ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&2459027012145119232) != 0) || ((int64((_la-92)) & ^0x3f) == 0 && ((int64(1)<<(_la-92))&-113665638399) != 0) || ((int64((_la-156)) & ^0x3f) == 0 && ((int64(1)<<(_la-156))&-1) != 0) || ((int64((_la-220)) & ^0x3f) == 0 && ((int64(1)<<(_la-220))&-9663676417) != 0) || ((int64((_la-284)) & ^0x3f) == 0 && ((int64(1)<<(_la-284))&-1) != 0) || ((int64((_la-348)) & ^0x3f) == 0 && ((int64(1)<<(_la-348))&-1) != 0) || ((int64((_la-412)) & ^0x3f) == 0 && ((int64(1)<<(_la-412))&-1152925902653358081) != 0) || ((int64((_la-476)) & ^0x3f) == 0 && ((int64(1)<<(_la-476))&-8796764110849) != 0) || ((int64((_la-540)) & ^0x3f) == 0 && ((int64(1)<<(_la-540))&-1) != 0) || ((int64((_la-604)) & ^0x3f) == 0 && ((int64(1)<<(_la-604))&432345718846390271) != 0) {
		{
			p.SetState(5715)
			p.Colid()
		}
		{
			p.SetState(5716)
			p.Match(PostgreSQLParserDOT)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

		p.SetState(5722)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}
		_la = p.GetTokenStream().LA(1)
	}
	{
		p.SetState(5723)
		p.All_op()
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IOperator_with_argtypes_listContext is an interface to support dynamic dispatch.
type IOperator_with_argtypes_listContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	AllOperator_with_argtypes() []IOperator_with_argtypesContext
	Operator_with_argtypes(i int) IOperator_with_argtypesContext
	AllCOMMA() []antlr.TerminalNode
	COMMA(i int) antlr.TerminalNode

	// IsOperator_with_argtypes_listContext differentiates from other interfaces.
	IsOperator_with_argtypes_listContext()
}

type Operator_with_argtypes_listContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyOperator_with_argtypes_listContext() *Operator_with_argtypes_listContext {
	var p = new(Operator_with_argtypes_listContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_operator_with_argtypes_list
	return p
}

func InitEmptyOperator_with_argtypes_listContext(p *Operator_with_argtypes_listContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_operator_with_argtypes_list
}

func (*Operator_with_argtypes_listContext) IsOperator_with_argtypes_listContext() {}

func NewOperator_with_argtypes_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Operator_with_argtypes_listContext {
	var p = new(Operator_with_argtypes_listContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_operator_with_argtypes_list

	return p
}

func (s *Operator_with_argtypes_listContext) GetParser() antlr.Parser { return s.parser }

func (s *Operator_with_argtypes_listContext) AllOperator_with_argtypes() []IOperator_with_argtypesContext {
	children := s.GetChildren()
	len := 0
	for _, ctx := range children {
		if _, ok := ctx.(IOperator_with_argtypesContext); ok {
			len++
		}
	}

	tst := make([]IOperator_with_argtypesContext, len)
	i := 0
	for _, ctx := range children {
		if t, ok := ctx.(IOperator_with_argtypesContext); ok {
			tst[i] = t.(IOperator_with_argtypesContext)
			i++
		}
	}

	return tst
}

func (s *Operator_with_argtypes_listContext) Operator_with_argtypes(i int) IOperator_with_argtypesContext {
	var t antlr.RuleContext
	j := 0
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOperator_with_argtypesContext); ok {
			if j == i {
				t = ctx.(antlr.RuleContext)
				break
			}
			j++
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOperator_with_argtypesContext)
}

func (s *Operator_with_argtypes_listContext) AllCOMMA() []antlr.TerminalNode {
	return s.GetTokens(PostgreSQLParserCOMMA)
}

func (s *Operator_with_argtypes_listContext) COMMA(i int) antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCOMMA, i)
}

func (s *Operator_with_argtypes_listContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Operator_with_argtypes_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Operator_with_argtypes_listContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterOperator_with_argtypes_list(s)
	}
}

func (s *Operator_with_argtypes_listContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitOperator_with_argtypes_list(s)
	}
}

func (s *Operator_with_argtypes_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitOperator_with_argtypes_list(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Operator_with_argtypes_list() (localctx IOperator_with_argtypes_listContext) {
	localctx = NewOperator_with_argtypes_listContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 686, PostgreSQLParserRULE_operator_with_argtypes_list)
	var _la int

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(5725)
		p.Operator_with_argtypes()
	}
	p.SetState(5730)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}
	_la = p.GetTokenStream().LA(1)

	for _la == PostgreSQLParserCOMMA {
		{
			p.SetState(5726)
			p.Match(PostgreSQLParserCOMMA)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5727)
			p.Operator_with_argtypes()
		}

		p.SetState(5732)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}
		_la = p.GetTokenStream().LA(1)
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IOperator_with_argtypesContext is an interface to support dynamic dispatch.
type IOperator_with_argtypesContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Any_operator() IAny_operatorContext
	Oper_argtypes() IOper_argtypesContext

	// IsOperator_with_argtypesContext differentiates from other interfaces.
	IsOperator_with_argtypesContext()
}

type Operator_with_argtypesContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyOperator_with_argtypesContext() *Operator_with_argtypesContext {
	var p = new(Operator_with_argtypesContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_operator_with_argtypes
	return p
}

func InitEmptyOperator_with_argtypesContext(p *Operator_with_argtypesContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_operator_with_argtypes
}

func (*Operator_with_argtypesContext) IsOperator_with_argtypesContext() {}

func NewOperator_with_argtypesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Operator_with_argtypesContext {
	var p = new(Operator_with_argtypesContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_operator_with_argtypes

	return p
}

func (s *Operator_with_argtypesContext) GetParser() antlr.Parser { return s.parser }

func (s *Operator_with_argtypesContext) Any_operator() IAny_operatorContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IAny_operatorContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IAny_operatorContext)
}

func (s *Operator_with_argtypesContext) Oper_argtypes() IOper_argtypesContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOper_argtypesContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOper_argtypesContext)
}

func (s *Operator_with_argtypesContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Operator_with_argtypesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Operator_with_argtypesContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterOperator_with_argtypes(s)
	}
}

func (s *Operator_with_argtypesContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitOperator_with_argtypes(s)
	}
}

func (s *Operator_with_argtypesContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitOperator_with_argtypes(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Operator_with_argtypes() (localctx IOperator_with_argtypesContext) {
	localctx = NewOperator_with_argtypesContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 688, PostgreSQLParserRULE_operator_with_argtypes)
	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(5733)
		p.Any_operator()
	}
	{
		p.SetState(5734)
		p.Oper_argtypes()
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IDostmtContext is an interface to support dynamic dispatch.
type IDostmtContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	DO() antlr.TerminalNode
	Dostmt_opt_list() IDostmt_opt_listContext

	// IsDostmtContext differentiates from other interfaces.
	IsDostmtContext()
}

type DostmtContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyDostmtContext() *DostmtContext {
	var p = new(DostmtContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_dostmt
	return p
}

func InitEmptyDostmtContext(p *DostmtContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_dostmt
}

func (*DostmtContext) IsDostmtContext() {}

func NewDostmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DostmtContext {
	var p = new(DostmtContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_dostmt

	return p
}

func (s *DostmtContext) GetParser() antlr.Parser { return s.parser }

func (s *DostmtContext) DO() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserDO, 0)
}

func (s *DostmtContext) Dostmt_opt_list() IDostmt_opt_listContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IDostmt_opt_listContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IDostmt_opt_listContext)
}

func (s *DostmtContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *DostmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *DostmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterDostmt(s)
	}
}

func (s *DostmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitDostmt(s)
	}
}

func (s *DostmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitDostmt(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Dostmt() (localctx IDostmtContext) {
	localctx = NewDostmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 690, PostgreSQLParserRULE_dostmt)
	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(5736)
		p.Match(PostgreSQLParserDO)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(5737)
		p.Dostmt_opt_list()
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IDostmt_opt_listContext is an interface to support dynamic dispatch.
type IDostmt_opt_listContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	AllDostmt_opt_item() []IDostmt_opt_itemContext
	Dostmt_opt_item(i int) IDostmt_opt_itemContext

	// IsDostmt_opt_listContext differentiates from other interfaces.
	IsDostmt_opt_listContext()
}

type Dostmt_opt_listContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyDostmt_opt_listContext() *Dostmt_opt_listContext {
	var p = new(Dostmt_opt_listContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_dostmt_opt_list
	return p
}

func InitEmptyDostmt_opt_listContext(p *Dostmt_opt_listContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_dostmt_opt_list
}

func (*Dostmt_opt_listContext) IsDostmt_opt_listContext() {}

func NewDostmt_opt_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Dostmt_opt_listContext {
	var p = new(Dostmt_opt_listContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_dostmt_opt_list

	return p
}

func (s *Dostmt_opt_listContext) GetParser() antlr.Parser { return s.parser }

func (s *Dostmt_opt_listContext) AllDostmt_opt_item() []IDostmt_opt_itemContext {
	children := s.GetChildren()
	len := 0
	for _, ctx := range children {
		if _, ok := ctx.(IDostmt_opt_itemContext); ok {
			len++
		}
	}

	tst := make([]IDostmt_opt_itemContext, len)
	i := 0
	for _, ctx := range children {
		if t, ok := ctx.(IDostmt_opt_itemContext); ok {
			tst[i] = t.(IDostmt_opt_itemContext)
			i++
		}
	}

	return tst
}

func (s *Dostmt_opt_listContext) Dostmt_opt_item(i int) IDostmt_opt_itemContext {
	var t antlr.RuleContext
	j := 0
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IDostmt_opt_itemContext); ok {
			if j == i {
				t = ctx.(antlr.RuleContext)
				break
			}
			j++
		}
	}

	if t == nil {
		return nil
	}

	return t.(IDostmt_opt_itemContext)
}

func (s *Dostmt_opt_listContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Dostmt_opt_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Dostmt_opt_listContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterDostmt_opt_list(s)
	}
}

func (s *Dostmt_opt_listContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitDostmt_opt_list(s)
	}
}

func (s *Dostmt_opt_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitDostmt_opt_list(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Dostmt_opt_list() (localctx IDostmt_opt_listContext) {
	localctx = NewDostmt_opt_listContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 692, PostgreSQLParserRULE_dostmt_opt_list)
	var _la int

	p.EnterOuterAlt(localctx, 1)
	p.SetState(5740)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}
	_la = p.GetTokenStream().LA(1)

	for ok := true; ok; ok = _la == PostgreSQLParserLANGUAGE || ((int64((_la-645)) & ^0x3f) == 0 && ((int64(1)<<(_la-645))&67108885) != 0) {
		{
			p.SetState(5739)
			p.Dostmt_opt_item()
		}

		p.SetState(5742)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}
		_la = p.GetTokenStream().LA(1)
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IDostmt_opt_itemContext is an interface to support dynamic dispatch.
type IDostmt_opt_itemContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Sconst() ISconstContext
	LANGUAGE() antlr.TerminalNode
	Nonreservedword_or_sconst() INonreservedword_or_sconstContext

	// IsDostmt_opt_itemContext differentiates from other interfaces.
	IsDostmt_opt_itemContext()
}

type Dostmt_opt_itemContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyDostmt_opt_itemContext() *Dostmt_opt_itemContext {
	var p = new(Dostmt_opt_itemContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_dostmt_opt_item
	return p
}

func InitEmptyDostmt_opt_itemContext(p *Dostmt_opt_itemContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_dostmt_opt_item
}

func (*Dostmt_opt_itemContext) IsDostmt_opt_itemContext() {}

func NewDostmt_opt_itemContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Dostmt_opt_itemContext {
	var p = new(Dostmt_opt_itemContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_dostmt_opt_item

	return p
}

func (s *Dostmt_opt_itemContext) GetParser() antlr.Parser { return s.parser }

func (s *Dostmt_opt_itemContext) Sconst() ISconstContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ISconstContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ISconstContext)
}

func (s *Dostmt_opt_itemContext) LANGUAGE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserLANGUAGE, 0)
}

func (s *Dostmt_opt_itemContext) Nonreservedword_or_sconst() INonreservedword_or_sconstContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(INonreservedword_or_sconstContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(INonreservedword_or_sconstContext)
}

func (s *Dostmt_opt_itemContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Dostmt_opt_itemContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Dostmt_opt_itemContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterDostmt_opt_item(s)
	}
}

func (s *Dostmt_opt_itemContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitDostmt_opt_item(s)
	}
}

func (s *Dostmt_opt_itemContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitDostmt_opt_item(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Dostmt_opt_item() (localctx IDostmt_opt_itemContext) {
	localctx = NewDostmt_opt_itemContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 694, PostgreSQLParserRULE_dostmt_opt_item)
	p.SetState(5747)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetTokenStream().LA(1) {
	case PostgreSQLParserStringConstant, PostgreSQLParserUnicodeEscapeStringConstant, PostgreSQLParserBeginDollarStringConstant, PostgreSQLParserEscapeStringConstant:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(5744)
			p.Sconst()
		}

	case PostgreSQLParserLANGUAGE:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(5745)
			p.Match(PostgreSQLParserLANGUAGE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5746)
			p.Nonreservedword_or_sconst()
		}

	default:
		p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// ICreatecaststmtContext is an interface to support dynamic dispatch.
type ICreatecaststmtContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	CREATE() antlr.TerminalNode
	CAST() antlr.TerminalNode
	OPEN_PAREN() antlr.TerminalNode
	AllTypename() []ITypenameContext
	Typename(i int) ITypenameContext
	AS() antlr.TerminalNode
	CLOSE_PAREN() antlr.TerminalNode
	WITH() antlr.TerminalNode
	FUNCTION() antlr.TerminalNode
	Function_with_argtypes() IFunction_with_argtypesContext
	Cast_context() ICast_contextContext
	WITHOUT() antlr.TerminalNode
	INOUT() antlr.TerminalNode

	// IsCreatecaststmtContext differentiates from other interfaces.
	IsCreatecaststmtContext()
}

type CreatecaststmtContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyCreatecaststmtContext() *CreatecaststmtContext {
	var p = new(CreatecaststmtContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_createcaststmt
	return p
}

func InitEmptyCreatecaststmtContext(p *CreatecaststmtContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_createcaststmt
}

func (*CreatecaststmtContext) IsCreatecaststmtContext() {}

func NewCreatecaststmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CreatecaststmtContext {
	var p = new(CreatecaststmtContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_createcaststmt

	return p
}

func (s *CreatecaststmtContext) GetParser() antlr.Parser { return s.parser }

func (s *CreatecaststmtContext) CREATE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCREATE, 0)
}

func (s *CreatecaststmtContext) CAST() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCAST, 0)
}

func (s *CreatecaststmtContext) OPEN_PAREN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserOPEN_PAREN, 0)
}

func (s *CreatecaststmtContext) AllTypename() []ITypenameContext {
	children := s.GetChildren()
	len := 0
	for _, ctx := range children {
		if _, ok := ctx.(ITypenameContext); ok {
			len++
		}
	}

	tst := make([]ITypenameContext, len)
	i := 0
	for _, ctx := range children {
		if t, ok := ctx.(ITypenameContext); ok {
			tst[i] = t.(ITypenameContext)
			i++
		}
	}

	return tst
}

func (s *CreatecaststmtContext) Typename(i int) ITypenameContext {
	var t antlr.RuleContext
	j := 0
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ITypenameContext); ok {
			if j == i {
				t = ctx.(antlr.RuleContext)
				break
			}
			j++
		}
	}

	if t == nil {
		return nil
	}

	return t.(ITypenameContext)
}

func (s *CreatecaststmtContext) AS() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserAS, 0)
}

func (s *CreatecaststmtContext) CLOSE_PAREN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCLOSE_PAREN, 0)
}

func (s *CreatecaststmtContext) WITH() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserWITH, 0)
}

func (s *CreatecaststmtContext) FUNCTION() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserFUNCTION, 0)
}

func (s *CreatecaststmtContext) Function_with_argtypes() IFunction_with_argtypesContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IFunction_with_argtypesContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IFunction_with_argtypesContext)
}

func (s *CreatecaststmtContext) Cast_context() ICast_contextContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ICast_contextContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ICast_contextContext)
}

func (s *CreatecaststmtContext) WITHOUT() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserWITHOUT, 0)
}

func (s *CreatecaststmtContext) INOUT() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserINOUT, 0)
}

func (s *CreatecaststmtContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *CreatecaststmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *CreatecaststmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterCreatecaststmt(s)
	}
}

func (s *CreatecaststmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitCreatecaststmt(s)
	}
}

func (s *CreatecaststmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitCreatecaststmt(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Createcaststmt() (localctx ICreatecaststmtContext) {
	localctx = NewCreatecaststmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 696, PostgreSQLParserRULE_createcaststmt)
	p.SetState(5783)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 303, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(5749)
			p.Match(PostgreSQLParserCREATE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5750)
			p.Match(PostgreSQLParserCAST)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5751)
			p.Match(PostgreSQLParserOPEN_PAREN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5752)
			p.Typename()
		}
		{
			p.SetState(5753)
			p.Match(PostgreSQLParserAS)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5754)
			p.Typename()
		}
		{
			p.SetState(5755)
			p.Match(PostgreSQLParserCLOSE_PAREN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5756)
			p.Match(PostgreSQLParserWITH)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5757)
			p.Match(PostgreSQLParserFUNCTION)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5758)
			p.Function_with_argtypes()
		}
		{
			p.SetState(5759)
			p.Cast_context()
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(5761)
			p.Match(PostgreSQLParserCREATE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5762)
			p.Match(PostgreSQLParserCAST)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5763)
			p.Match(PostgreSQLParserOPEN_PAREN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5764)
			p.Typename()
		}
		{
			p.SetState(5765)
			p.Match(PostgreSQLParserAS)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5766)
			p.Typename()
		}
		{
			p.SetState(5767)
			p.Match(PostgreSQLParserCLOSE_PAREN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5768)
			p.Match(PostgreSQLParserWITHOUT)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5769)
			p.Match(PostgreSQLParserFUNCTION)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5770)
			p.Cast_context()
		}

	case 3:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(5772)
			p.Match(PostgreSQLParserCREATE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5773)
			p.Match(PostgreSQLParserCAST)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5774)
			p.Match(PostgreSQLParserOPEN_PAREN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5775)
			p.Typename()
		}
		{
			p.SetState(5776)
			p.Match(PostgreSQLParserAS)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5777)
			p.Typename()
		}
		{
			p.SetState(5778)
			p.Match(PostgreSQLParserCLOSE_PAREN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5779)
			p.Match(PostgreSQLParserWITH)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5780)
			p.Match(PostgreSQLParserINOUT)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5781)
			p.Cast_context()
		}

	case antlr.ATNInvalidAltNumber:
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// ICast_contextContext is an interface to support dynamic dispatch.
type ICast_contextContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	AS() antlr.TerminalNode
	IMPLICIT_P() antlr.TerminalNode
	ASSIGNMENT() antlr.TerminalNode

	// IsCast_contextContext differentiates from other interfaces.
	IsCast_contextContext()
}

type Cast_contextContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyCast_contextContext() *Cast_contextContext {
	var p = new(Cast_contextContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_cast_context
	return p
}

func InitEmptyCast_contextContext(p *Cast_contextContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_cast_context
}

func (*Cast_contextContext) IsCast_contextContext() {}

func NewCast_contextContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Cast_contextContext {
	var p = new(Cast_contextContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_cast_context

	return p
}

func (s *Cast_contextContext) GetParser() antlr.Parser { return s.parser }

func (s *Cast_contextContext) AS() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserAS, 0)
}

func (s *Cast_contextContext) IMPLICIT_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserIMPLICIT_P, 0)
}

func (s *Cast_contextContext) ASSIGNMENT() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserASSIGNMENT, 0)
}

func (s *Cast_contextContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Cast_contextContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Cast_contextContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterCast_context(s)
	}
}

func (s *Cast_contextContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitCast_context(s)
	}
}

func (s *Cast_contextContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitCast_context(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Cast_context() (localctx ICast_contextContext) {
	localctx = NewCast_contextContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 698, PostgreSQLParserRULE_cast_context)
	p.SetState(5790)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 304, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(5785)
			p.Match(PostgreSQLParserAS)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5786)
			p.Match(PostgreSQLParserIMPLICIT_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(5787)
			p.Match(PostgreSQLParserAS)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5788)
			p.Match(PostgreSQLParserASSIGNMENT)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 3:
		p.EnterOuterAlt(localctx, 3)

	case antlr.ATNInvalidAltNumber:
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IDropcaststmtContext is an interface to support dynamic dispatch.
type IDropcaststmtContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	DROP() antlr.TerminalNode
	CAST() antlr.TerminalNode
	Opt_if_exists() IOpt_if_existsContext
	OPEN_PAREN() antlr.TerminalNode
	AllTypename() []ITypenameContext
	Typename(i int) ITypenameContext
	AS() antlr.TerminalNode
	CLOSE_PAREN() antlr.TerminalNode
	Opt_drop_behavior() IOpt_drop_behaviorContext

	// IsDropcaststmtContext differentiates from other interfaces.
	IsDropcaststmtContext()
}

type DropcaststmtContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyDropcaststmtContext() *DropcaststmtContext {
	var p = new(DropcaststmtContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_dropcaststmt
	return p
}

func InitEmptyDropcaststmtContext(p *DropcaststmtContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_dropcaststmt
}

func (*DropcaststmtContext) IsDropcaststmtContext() {}

func NewDropcaststmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DropcaststmtContext {
	var p = new(DropcaststmtContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_dropcaststmt

	return p
}

func (s *DropcaststmtContext) GetParser() antlr.Parser { return s.parser }

func (s *DropcaststmtContext) DROP() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserDROP, 0)
}

func (s *DropcaststmtContext) CAST() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCAST, 0)
}

func (s *DropcaststmtContext) Opt_if_exists() IOpt_if_existsContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOpt_if_existsContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOpt_if_existsContext)
}

func (s *DropcaststmtContext) OPEN_PAREN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserOPEN_PAREN, 0)
}

func (s *DropcaststmtContext) AllTypename() []ITypenameContext {
	children := s.GetChildren()
	len := 0
	for _, ctx := range children {
		if _, ok := ctx.(ITypenameContext); ok {
			len++
		}
	}

	tst := make([]ITypenameContext, len)
	i := 0
	for _, ctx := range children {
		if t, ok := ctx.(ITypenameContext); ok {
			tst[i] = t.(ITypenameContext)
			i++
		}
	}

	return tst
}

func (s *DropcaststmtContext) Typename(i int) ITypenameContext {
	var t antlr.RuleContext
	j := 0
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ITypenameContext); ok {
			if j == i {
				t = ctx.(antlr.RuleContext)
				break
			}
			j++
		}
	}

	if t == nil {
		return nil
	}

	return t.(ITypenameContext)
}

func (s *DropcaststmtContext) AS() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserAS, 0)
}

func (s *DropcaststmtContext) CLOSE_PAREN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCLOSE_PAREN, 0)
}

func (s *DropcaststmtContext) Opt_drop_behavior() IOpt_drop_behaviorContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOpt_drop_behaviorContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOpt_drop_behaviorContext)
}

func (s *DropcaststmtContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *DropcaststmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *DropcaststmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterDropcaststmt(s)
	}
}

func (s *DropcaststmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitDropcaststmt(s)
	}
}

func (s *DropcaststmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitDropcaststmt(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Dropcaststmt() (localctx IDropcaststmtContext) {
	localctx = NewDropcaststmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 700, PostgreSQLParserRULE_dropcaststmt)
	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(5792)
		p.Match(PostgreSQLParserDROP)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(5793)
		p.Match(PostgreSQLParserCAST)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(5794)
		p.Opt_if_exists()
	}
	{
		p.SetState(5795)
		p.Match(PostgreSQLParserOPEN_PAREN)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(5796)
		p.Typename()
	}
	{
		p.SetState(5797)
		p.Match(PostgreSQLParserAS)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(5798)
		p.Typename()
	}
	{
		p.SetState(5799)
		p.Match(PostgreSQLParserCLOSE_PAREN)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(5800)
		p.Opt_drop_behavior()
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IOpt_if_existsContext is an interface to support dynamic dispatch.
type IOpt_if_existsContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	IF_P() antlr.TerminalNode
	EXISTS() antlr.TerminalNode

	// IsOpt_if_existsContext differentiates from other interfaces.
	IsOpt_if_existsContext()
}

type Opt_if_existsContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyOpt_if_existsContext() *Opt_if_existsContext {
	var p = new(Opt_if_existsContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opt_if_exists
	return p
}

func InitEmptyOpt_if_existsContext(p *Opt_if_existsContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opt_if_exists
}

func (*Opt_if_existsContext) IsOpt_if_existsContext() {}

func NewOpt_if_existsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_if_existsContext {
	var p = new(Opt_if_existsContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_opt_if_exists

	return p
}

func (s *Opt_if_existsContext) GetParser() antlr.Parser { return s.parser }

func (s *Opt_if_existsContext) IF_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserIF_P, 0)
}

func (s *Opt_if_existsContext) EXISTS() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserEXISTS, 0)
}

func (s *Opt_if_existsContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Opt_if_existsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Opt_if_existsContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterOpt_if_exists(s)
	}
}

func (s *Opt_if_existsContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitOpt_if_exists(s)
	}
}

func (s *Opt_if_existsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitOpt_if_exists(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Opt_if_exists() (localctx IOpt_if_existsContext) {
	localctx = NewOpt_if_existsContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 702, PostgreSQLParserRULE_opt_if_exists)
	p.SetState(5805)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetTokenStream().LA(1) {
	case PostgreSQLParserIF_P:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(5802)
			p.Match(PostgreSQLParserIF_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5803)
			p.Match(PostgreSQLParserEXISTS)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case PostgreSQLParserOPEN_PAREN, PostgreSQLParserFOR:
		p.EnterOuterAlt(localctx, 2)

	default:
		p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// ICreatetransformstmtContext is an interface to support dynamic dispatch.
type ICreatetransformstmtContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	CREATE() antlr.TerminalNode
	Opt_or_replace() IOpt_or_replaceContext
	TRANSFORM() antlr.TerminalNode
	FOR() antlr.TerminalNode
	Typename() ITypenameContext
	LANGUAGE() antlr.TerminalNode
	Name() INameContext
	OPEN_PAREN() antlr.TerminalNode
	Transform_element_list() ITransform_element_listContext
	CLOSE_PAREN() antlr.TerminalNode

	// IsCreatetransformstmtContext differentiates from other interfaces.
	IsCreatetransformstmtContext()
}

type CreatetransformstmtContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyCreatetransformstmtContext() *CreatetransformstmtContext {
	var p = new(CreatetransformstmtContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_createtransformstmt
	return p
}

func InitEmptyCreatetransformstmtContext(p *CreatetransformstmtContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_createtransformstmt
}

func (*CreatetransformstmtContext) IsCreatetransformstmtContext() {}

func NewCreatetransformstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CreatetransformstmtContext {
	var p = new(CreatetransformstmtContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_createtransformstmt

	return p
}

func (s *CreatetransformstmtContext) GetParser() antlr.Parser { return s.parser }

func (s *CreatetransformstmtContext) CREATE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCREATE, 0)
}

func (s *CreatetransformstmtContext) Opt_or_replace() IOpt_or_replaceContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOpt_or_replaceContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOpt_or_replaceContext)
}

func (s *CreatetransformstmtContext) TRANSFORM() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserTRANSFORM, 0)
}

func (s *CreatetransformstmtContext) FOR() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserFOR, 0)
}

func (s *CreatetransformstmtContext) Typename() ITypenameContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ITypenameContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ITypenameContext)
}

func (s *CreatetransformstmtContext) LANGUAGE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserLANGUAGE, 0)
}

func (s *CreatetransformstmtContext) Name() INameContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(INameContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(INameContext)
}

func (s *CreatetransformstmtContext) OPEN_PAREN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserOPEN_PAREN, 0)
}

func (s *CreatetransformstmtContext) Transform_element_list() ITransform_element_listContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ITransform_element_listContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ITransform_element_listContext)
}

func (s *CreatetransformstmtContext) CLOSE_PAREN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCLOSE_PAREN, 0)
}

func (s *CreatetransformstmtContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *CreatetransformstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *CreatetransformstmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterCreatetransformstmt(s)
	}
}

func (s *CreatetransformstmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitCreatetransformstmt(s)
	}
}

func (s *CreatetransformstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitCreatetransformstmt(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Createtransformstmt() (localctx ICreatetransformstmtContext) {
	localctx = NewCreatetransformstmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 704, PostgreSQLParserRULE_createtransformstmt)
	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(5807)
		p.Match(PostgreSQLParserCREATE)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(5808)
		p.Opt_or_replace()
	}
	{
		p.SetState(5809)
		p.Match(PostgreSQLParserTRANSFORM)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(5810)
		p.Match(PostgreSQLParserFOR)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(5811)
		p.Typename()
	}
	{
		p.SetState(5812)
		p.Match(PostgreSQLParserLANGUAGE)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(5813)
		p.Name()
	}
	{
		p.SetState(5814)
		p.Match(PostgreSQLParserOPEN_PAREN)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(5815)
		p.Transform_element_list()
	}
	{
		p.SetState(5816)
		p.Match(PostgreSQLParserCLOSE_PAREN)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// ITransform_element_listContext is an interface to support dynamic dispatch.
type ITransform_element_listContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	FROM() antlr.TerminalNode
	AllSQL_P() []antlr.TerminalNode
	SQL_P(i int) antlr.TerminalNode
	AllWITH() []antlr.TerminalNode
	WITH(i int) antlr.TerminalNode
	AllFUNCTION() []antlr.TerminalNode
	FUNCTION(i int) antlr.TerminalNode
	AllFunction_with_argtypes() []IFunction_with_argtypesContext
	Function_with_argtypes(i int) IFunction_with_argtypesContext
	COMMA() antlr.TerminalNode
	TO() antlr.TerminalNode

	// IsTransform_element_listContext differentiates from other interfaces.
	IsTransform_element_listContext()
}

type Transform_element_listContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyTransform_element_listContext() *Transform_element_listContext {
	var p = new(Transform_element_listContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_transform_element_list
	return p
}

func InitEmptyTransform_element_listContext(p *Transform_element_listContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_transform_element_list
}

func (*Transform_element_listContext) IsTransform_element_listContext() {}

func NewTransform_element_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Transform_element_listContext {
	var p = new(Transform_element_listContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_transform_element_list

	return p
}

func (s *Transform_element_listContext) GetParser() antlr.Parser { return s.parser }

func (s *Transform_element_listContext) FROM() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserFROM, 0)
}

func (s *Transform_element_listContext) AllSQL_P() []antlr.TerminalNode {
	return s.GetTokens(PostgreSQLParserSQL_P)
}

func (s *Transform_element_listContext) SQL_P(i int) antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserSQL_P, i)
}

func (s *Transform_element_listContext) AllWITH() []antlr.TerminalNode {
	return s.GetTokens(PostgreSQLParserWITH)
}

func (s *Transform_element_listContext) WITH(i int) antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserWITH, i)
}

func (s *Transform_element_listContext) AllFUNCTION() []antlr.TerminalNode {
	return s.GetTokens(PostgreSQLParserFUNCTION)
}

func (s *Transform_element_listContext) FUNCTION(i int) antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserFUNCTION, i)
}

func (s *Transform_element_listContext) AllFunction_with_argtypes() []IFunction_with_argtypesContext {
	children := s.GetChildren()
	len := 0
	for _, ctx := range children {
		if _, ok := ctx.(IFunction_with_argtypesContext); ok {
			len++
		}
	}

	tst := make([]IFunction_with_argtypesContext, len)
	i := 0
	for _, ctx := range children {
		if t, ok := ctx.(IFunction_with_argtypesContext); ok {
			tst[i] = t.(IFunction_with_argtypesContext)
			i++
		}
	}

	return tst
}

func (s *Transform_element_listContext) Function_with_argtypes(i int) IFunction_with_argtypesContext {
	var t antlr.RuleContext
	j := 0
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IFunction_with_argtypesContext); ok {
			if j == i {
				t = ctx.(antlr.RuleContext)
				break
			}
			j++
		}
	}

	if t == nil {
		return nil
	}

	return t.(IFunction_with_argtypesContext)
}

func (s *Transform_element_listContext) COMMA() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCOMMA, 0)
}

func (s *Transform_element_listContext) TO() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserTO, 0)
}

func (s *Transform_element_listContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Transform_element_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Transform_element_listContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterTransform_element_list(s)
	}
}

func (s *Transform_element_listContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitTransform_element_list(s)
	}
}

func (s *Transform_element_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitTransform_element_list(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Transform_element_list() (localctx ITransform_element_listContext) {
	localctx = NewTransform_element_listContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 706, PostgreSQLParserRULE_transform_element_list)
	p.SetState(5852)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 306, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(5818)
			p.Match(PostgreSQLParserFROM)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5819)
			p.Match(PostgreSQLParserSQL_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5820)
			p.Match(PostgreSQLParserWITH)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5821)
			p.Match(PostgreSQLParserFUNCTION)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5822)
			p.Function_with_argtypes()
		}
		{
			p.SetState(5823)
			p.Match(PostgreSQLParserCOMMA)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5824)
			p.Match(PostgreSQLParserTO)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5825)
			p.Match(PostgreSQLParserSQL_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5826)
			p.Match(PostgreSQLParserWITH)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5827)
			p.Match(PostgreSQLParserFUNCTION)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5828)
			p.Function_with_argtypes()
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(5830)
			p.Match(PostgreSQLParserTO)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5831)
			p.Match(PostgreSQLParserSQL_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5832)
			p.Match(PostgreSQLParserWITH)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5833)
			p.Match(PostgreSQLParserFUNCTION)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5834)
			p.Function_with_argtypes()
		}
		{
			p.SetState(5835)
			p.Match(PostgreSQLParserCOMMA)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5836)
			p.Match(PostgreSQLParserFROM)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5837)
			p.Match(PostgreSQLParserSQL_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5838)
			p.Match(PostgreSQLParserWITH)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5839)
			p.Match(PostgreSQLParserFUNCTION)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5840)
			p.Function_with_argtypes()
		}

	case 3:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(5842)
			p.Match(PostgreSQLParserFROM)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5843)
			p.Match(PostgreSQLParserSQL_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5844)
			p.Match(PostgreSQLParserWITH)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5845)
			p.Match(PostgreSQLParserFUNCTION)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5846)
			p.Function_with_argtypes()
		}

	case 4:
		p.EnterOuterAlt(localctx, 4)
		{
			p.SetState(5847)
			p.Match(PostgreSQLParserTO)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5848)
			p.Match(PostgreSQLParserSQL_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5849)
			p.Match(PostgreSQLParserWITH)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5850)
			p.Match(PostgreSQLParserFUNCTION)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5851)
			p.Function_with_argtypes()
		}

	case antlr.ATNInvalidAltNumber:
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IDroptransformstmtContext is an interface to support dynamic dispatch.
type IDroptransformstmtContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	DROP() antlr.TerminalNode
	TRANSFORM() antlr.TerminalNode
	Opt_if_exists() IOpt_if_existsContext
	FOR() antlr.TerminalNode
	Typename() ITypenameContext
	LANGUAGE() antlr.TerminalNode
	Name() INameContext
	Opt_drop_behavior() IOpt_drop_behaviorContext

	// IsDroptransformstmtContext differentiates from other interfaces.
	IsDroptransformstmtContext()
}

type DroptransformstmtContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyDroptransformstmtContext() *DroptransformstmtContext {
	var p = new(DroptransformstmtContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_droptransformstmt
	return p
}

func InitEmptyDroptransformstmtContext(p *DroptransformstmtContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_droptransformstmt
}

func (*DroptransformstmtContext) IsDroptransformstmtContext() {}

func NewDroptransformstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DroptransformstmtContext {
	var p = new(DroptransformstmtContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_droptransformstmt

	return p
}

func (s *DroptransformstmtContext) GetParser() antlr.Parser { return s.parser }

func (s *DroptransformstmtContext) DROP() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserDROP, 0)
}

func (s *DroptransformstmtContext) TRANSFORM() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserTRANSFORM, 0)
}

func (s *DroptransformstmtContext) Opt_if_exists() IOpt_if_existsContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOpt_if_existsContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOpt_if_existsContext)
}

func (s *DroptransformstmtContext) FOR() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserFOR, 0)
}

func (s *DroptransformstmtContext) Typename() ITypenameContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ITypenameContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ITypenameContext)
}

func (s *DroptransformstmtContext) LANGUAGE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserLANGUAGE, 0)
}

func (s *DroptransformstmtContext) Name() INameContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(INameContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(INameContext)
}

func (s *DroptransformstmtContext) Opt_drop_behavior() IOpt_drop_behaviorContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOpt_drop_behaviorContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOpt_drop_behaviorContext)
}

func (s *DroptransformstmtContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *DroptransformstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *DroptransformstmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterDroptransformstmt(s)
	}
}

func (s *DroptransformstmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitDroptransformstmt(s)
	}
}

func (s *DroptransformstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitDroptransformstmt(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Droptransformstmt() (localctx IDroptransformstmtContext) {
	localctx = NewDroptransformstmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 708, PostgreSQLParserRULE_droptransformstmt)
	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(5854)
		p.Match(PostgreSQLParserDROP)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(5855)
		p.Match(PostgreSQLParserTRANSFORM)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(5856)
		p.Opt_if_exists()
	}
	{
		p.SetState(5857)
		p.Match(PostgreSQLParserFOR)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(5858)
		p.Typename()
	}
	{
		p.SetState(5859)
		p.Match(PostgreSQLParserLANGUAGE)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(5860)
		p.Name()
	}
	{
		p.SetState(5861)
		p.Opt_drop_behavior()
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IReindexstmtContext is an interface to support dynamic dispatch.
type IReindexstmtContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	REINDEX() antlr.TerminalNode
	Reindex_target_type() IReindex_target_typeContext
	Opt_concurrently() IOpt_concurrentlyContext
	Qualified_name() IQualified_nameContext
	Reindex_target_multitable() IReindex_target_multitableContext
	Name() INameContext
	OPEN_PAREN() antlr.TerminalNode
	Reindex_option_list() IReindex_option_listContext
	CLOSE_PAREN() antlr.TerminalNode

	// IsReindexstmtContext differentiates from other interfaces.
	IsReindexstmtContext()
}

type ReindexstmtContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyReindexstmtContext() *ReindexstmtContext {
	var p = new(ReindexstmtContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_reindexstmt
	return p
}

func InitEmptyReindexstmtContext(p *ReindexstmtContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_reindexstmt
}

func (*ReindexstmtContext) IsReindexstmtContext() {}

func NewReindexstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ReindexstmtContext {
	var p = new(ReindexstmtContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_reindexstmt

	return p
}

func (s *ReindexstmtContext) GetParser() antlr.Parser { return s.parser }

func (s *ReindexstmtContext) REINDEX() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserREINDEX, 0)
}

func (s *ReindexstmtContext) Reindex_target_type() IReindex_target_typeContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IReindex_target_typeContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IReindex_target_typeContext)
}

func (s *ReindexstmtContext) Opt_concurrently() IOpt_concurrentlyContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOpt_concurrentlyContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOpt_concurrentlyContext)
}

func (s *ReindexstmtContext) Qualified_name() IQualified_nameContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IQualified_nameContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IQualified_nameContext)
}

func (s *ReindexstmtContext) Reindex_target_multitable() IReindex_target_multitableContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IReindex_target_multitableContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IReindex_target_multitableContext)
}

func (s *ReindexstmtContext) Name() INameContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(INameContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(INameContext)
}

func (s *ReindexstmtContext) OPEN_PAREN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserOPEN_PAREN, 0)
}

func (s *ReindexstmtContext) Reindex_option_list() IReindex_option_listContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IReindex_option_listContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IReindex_option_listContext)
}

func (s *ReindexstmtContext) CLOSE_PAREN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCLOSE_PAREN, 0)
}

func (s *ReindexstmtContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *ReindexstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *ReindexstmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterReindexstmt(s)
	}
}

func (s *ReindexstmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitReindexstmt(s)
	}
}

func (s *ReindexstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitReindexstmt(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Reindexstmt() (localctx IReindexstmtContext) {
	localctx = NewReindexstmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 710, PostgreSQLParserRULE_reindexstmt)
	p.SetState(5889)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 307, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(5863)
			p.Match(PostgreSQLParserREINDEX)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5864)
			p.Reindex_target_type()
		}
		{
			p.SetState(5865)
			p.Opt_concurrently()
		}
		{
			p.SetState(5866)
			p.Qualified_name()
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(5868)
			p.Match(PostgreSQLParserREINDEX)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5869)
			p.Reindex_target_multitable()
		}
		{
			p.SetState(5870)
			p.Opt_concurrently()
		}
		{
			p.SetState(5871)
			p.Name()
		}

	case 3:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(5873)
			p.Match(PostgreSQLParserREINDEX)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5874)
			p.Match(PostgreSQLParserOPEN_PAREN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5875)
			p.Reindex_option_list()
		}
		{
			p.SetState(5876)
			p.Match(PostgreSQLParserCLOSE_PAREN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5877)
			p.Reindex_target_type()
		}
		{
			p.SetState(5878)
			p.Opt_concurrently()
		}
		{
			p.SetState(5879)
			p.Qualified_name()
		}

	case 4:
		p.EnterOuterAlt(localctx, 4)
		{
			p.SetState(5881)
			p.Match(PostgreSQLParserREINDEX)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5882)
			p.Match(PostgreSQLParserOPEN_PAREN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5883)
			p.Reindex_option_list()
		}
		{
			p.SetState(5884)
			p.Match(PostgreSQLParserCLOSE_PAREN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5885)
			p.Reindex_target_multitable()
		}
		{
			p.SetState(5886)
			p.Opt_concurrently()
		}
		{
			p.SetState(5887)
			p.Name()
		}

	case antlr.ATNInvalidAltNumber:
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IReindex_target_typeContext is an interface to support dynamic dispatch.
type IReindex_target_typeContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	INDEX() antlr.TerminalNode
	TABLE() antlr.TerminalNode
	SCHEMA() antlr.TerminalNode
	DATABASE() antlr.TerminalNode
	SYSTEM_P() antlr.TerminalNode

	// IsReindex_target_typeContext differentiates from other interfaces.
	IsReindex_target_typeContext()
}

type Reindex_target_typeContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyReindex_target_typeContext() *Reindex_target_typeContext {
	var p = new(Reindex_target_typeContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_reindex_target_type
	return p
}

func InitEmptyReindex_target_typeContext(p *Reindex_target_typeContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_reindex_target_type
}

func (*Reindex_target_typeContext) IsReindex_target_typeContext() {}

func NewReindex_target_typeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Reindex_target_typeContext {
	var p = new(Reindex_target_typeContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_reindex_target_type

	return p
}

func (s *Reindex_target_typeContext) GetParser() antlr.Parser { return s.parser }

func (s *Reindex_target_typeContext) INDEX() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserINDEX, 0)
}

func (s *Reindex_target_typeContext) TABLE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserTABLE, 0)
}

func (s *Reindex_target_typeContext) SCHEMA() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserSCHEMA, 0)
}

func (s *Reindex_target_typeContext) DATABASE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserDATABASE, 0)
}

func (s *Reindex_target_typeContext) SYSTEM_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserSYSTEM_P, 0)
}

func (s *Reindex_target_typeContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Reindex_target_typeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Reindex_target_typeContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterReindex_target_type(s)
	}
}

func (s *Reindex_target_typeContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitReindex_target_type(s)
	}
}

func (s *Reindex_target_typeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitReindex_target_type(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Reindex_target_type() (localctx IReindex_target_typeContext) {
	localctx = NewReindex_target_typeContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 712, PostgreSQLParserRULE_reindex_target_type)
	var _la int

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(5891)
		_la = p.GetTokenStream().LA(1)

		if !(_la == PostgreSQLParserTABLE || _la == PostgreSQLParserDATABASE || _la == PostgreSQLParserINDEX || _la == PostgreSQLParserSCHEMA || _la == PostgreSQLParserSYSTEM_P) {
			p.GetErrorHandler().RecoverInline(p)
		} else {
			p.GetErrorHandler().ReportMatch(p)
			p.Consume()
		}
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IReindex_target_multitableContext is an interface to support dynamic dispatch.
type IReindex_target_multitableContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	SCHEMA() antlr.TerminalNode
	SYSTEM_P() antlr.TerminalNode
	DATABASE() antlr.TerminalNode

	// IsReindex_target_multitableContext differentiates from other interfaces.
	IsReindex_target_multitableContext()
}

type Reindex_target_multitableContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyReindex_target_multitableContext() *Reindex_target_multitableContext {
	var p = new(Reindex_target_multitableContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_reindex_target_multitable
	return p
}

func InitEmptyReindex_target_multitableContext(p *Reindex_target_multitableContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_reindex_target_multitable
}

func (*Reindex_target_multitableContext) IsReindex_target_multitableContext() {}

func NewReindex_target_multitableContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Reindex_target_multitableContext {
	var p = new(Reindex_target_multitableContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_reindex_target_multitable

	return p
}

func (s *Reindex_target_multitableContext) GetParser() antlr.Parser { return s.parser }

func (s *Reindex_target_multitableContext) SCHEMA() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserSCHEMA, 0)
}

func (s *Reindex_target_multitableContext) SYSTEM_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserSYSTEM_P, 0)
}

func (s *Reindex_target_multitableContext) DATABASE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserDATABASE, 0)
}

func (s *Reindex_target_multitableContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Reindex_target_multitableContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Reindex_target_multitableContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterReindex_target_multitable(s)
	}
}

func (s *Reindex_target_multitableContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitReindex_target_multitable(s)
	}
}

func (s *Reindex_target_multitableContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitReindex_target_multitable(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Reindex_target_multitable() (localctx IReindex_target_multitableContext) {
	localctx = NewReindex_target_multitableContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 714, PostgreSQLParserRULE_reindex_target_multitable)
	var _la int

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(5893)
		_la = p.GetTokenStream().LA(1)

		if !(_la == PostgreSQLParserDATABASE || _la == PostgreSQLParserSCHEMA || _la == PostgreSQLParserSYSTEM_P) {
			p.GetErrorHandler().RecoverInline(p)
		} else {
			p.GetErrorHandler().ReportMatch(p)
			p.Consume()
		}
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IReindex_option_listContext is an interface to support dynamic dispatch.
type IReindex_option_listContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	AllReindex_option_elem() []IReindex_option_elemContext
	Reindex_option_elem(i int) IReindex_option_elemContext
	AllCOMMA() []antlr.TerminalNode
	COMMA(i int) antlr.TerminalNode

	// IsReindex_option_listContext differentiates from other interfaces.
	IsReindex_option_listContext()
}

type Reindex_option_listContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyReindex_option_listContext() *Reindex_option_listContext {
	var p = new(Reindex_option_listContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_reindex_option_list
	return p
}

func InitEmptyReindex_option_listContext(p *Reindex_option_listContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_reindex_option_list
}

func (*Reindex_option_listContext) IsReindex_option_listContext() {}

func NewReindex_option_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Reindex_option_listContext {
	var p = new(Reindex_option_listContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_reindex_option_list

	return p
}

func (s *Reindex_option_listContext) GetParser() antlr.Parser { return s.parser }

func (s *Reindex_option_listContext) AllReindex_option_elem() []IReindex_option_elemContext {
	children := s.GetChildren()
	len := 0
	for _, ctx := range children {
		if _, ok := ctx.(IReindex_option_elemContext); ok {
			len++
		}
	}

	tst := make([]IReindex_option_elemContext, len)
	i := 0
	for _, ctx := range children {
		if t, ok := ctx.(IReindex_option_elemContext); ok {
			tst[i] = t.(IReindex_option_elemContext)
			i++
		}
	}

	return tst
}

func (s *Reindex_option_listContext) Reindex_option_elem(i int) IReindex_option_elemContext {
	var t antlr.RuleContext
	j := 0
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IReindex_option_elemContext); ok {
			if j == i {
				t = ctx.(antlr.RuleContext)
				break
			}
			j++
		}
	}

	if t == nil {
		return nil
	}

	return t.(IReindex_option_elemContext)
}

func (s *Reindex_option_listContext) AllCOMMA() []antlr.TerminalNode {
	return s.GetTokens(PostgreSQLParserCOMMA)
}

func (s *Reindex_option_listContext) COMMA(i int) antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCOMMA, i)
}

func (s *Reindex_option_listContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Reindex_option_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Reindex_option_listContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterReindex_option_list(s)
	}
}

func (s *Reindex_option_listContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitReindex_option_list(s)
	}
}

func (s *Reindex_option_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitReindex_option_list(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Reindex_option_list() (localctx IReindex_option_listContext) {
	localctx = NewReindex_option_listContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 716, PostgreSQLParserRULE_reindex_option_list)
	var _la int

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(5895)
		p.Reindex_option_elem()
	}
	p.SetState(5900)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}
	_la = p.GetTokenStream().LA(1)

	for _la == PostgreSQLParserCOMMA {
		{
			p.SetState(5896)
			p.Match(PostgreSQLParserCOMMA)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5897)
			p.Reindex_option_elem()
		}

		p.SetState(5902)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}
		_la = p.GetTokenStream().LA(1)
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IReindex_option_elemContext is an interface to support dynamic dispatch.
type IReindex_option_elemContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	VERBOSE() antlr.TerminalNode
	TABLESPACE() antlr.TerminalNode
	CONCURRENTLY() antlr.TerminalNode

	// IsReindex_option_elemContext differentiates from other interfaces.
	IsReindex_option_elemContext()
}

type Reindex_option_elemContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyReindex_option_elemContext() *Reindex_option_elemContext {
	var p = new(Reindex_option_elemContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_reindex_option_elem
	return p
}

func InitEmptyReindex_option_elemContext(p *Reindex_option_elemContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_reindex_option_elem
}

func (*Reindex_option_elemContext) IsReindex_option_elemContext() {}

func NewReindex_option_elemContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Reindex_option_elemContext {
	var p = new(Reindex_option_elemContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_reindex_option_elem

	return p
}

func (s *Reindex_option_elemContext) GetParser() antlr.Parser { return s.parser }

func (s *Reindex_option_elemContext) VERBOSE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserVERBOSE, 0)
}

func (s *Reindex_option_elemContext) TABLESPACE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserTABLESPACE, 0)
}

func (s *Reindex_option_elemContext) CONCURRENTLY() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCONCURRENTLY, 0)
}

func (s *Reindex_option_elemContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Reindex_option_elemContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Reindex_option_elemContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterReindex_option_elem(s)
	}
}

func (s *Reindex_option_elemContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitReindex_option_elem(s)
	}
}

func (s *Reindex_option_elemContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitReindex_option_elem(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Reindex_option_elem() (localctx IReindex_option_elemContext) {
	localctx = NewReindex_option_elemContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 718, PostgreSQLParserRULE_reindex_option_elem)
	var _la int

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(5903)
		_la = p.GetTokenStream().LA(1)

		if !(_la == PostgreSQLParserCONCURRENTLY || _la == PostgreSQLParserVERBOSE || _la == PostgreSQLParserTABLESPACE) {
			p.GetErrorHandler().RecoverInline(p)
		} else {
			p.GetErrorHandler().ReportMatch(p)
			p.Consume()
		}
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IAltertblspcstmtContext is an interface to support dynamic dispatch.
type IAltertblspcstmtContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	ALTER() antlr.TerminalNode
	TABLESPACE() antlr.TerminalNode
	Name() INameContext
	SET() antlr.TerminalNode
	Reloptions() IReloptionsContext
	RESET() antlr.TerminalNode

	// IsAltertblspcstmtContext differentiates from other interfaces.
	IsAltertblspcstmtContext()
}

type AltertblspcstmtContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyAltertblspcstmtContext() *AltertblspcstmtContext {
	var p = new(AltertblspcstmtContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_altertblspcstmt
	return p
}

func InitEmptyAltertblspcstmtContext(p *AltertblspcstmtContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_altertblspcstmt
}

func (*AltertblspcstmtContext) IsAltertblspcstmtContext() {}

func NewAltertblspcstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AltertblspcstmtContext {
	var p = new(AltertblspcstmtContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_altertblspcstmt

	return p
}

func (s *AltertblspcstmtContext) GetParser() antlr.Parser { return s.parser }

func (s *AltertblspcstmtContext) ALTER() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserALTER, 0)
}

func (s *AltertblspcstmtContext) TABLESPACE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserTABLESPACE, 0)
}

func (s *AltertblspcstmtContext) Name() INameContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(INameContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(INameContext)
}

func (s *AltertblspcstmtContext) SET() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserSET, 0)
}

func (s *AltertblspcstmtContext) Reloptions() IReloptionsContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IReloptionsContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IReloptionsContext)
}

func (s *AltertblspcstmtContext) RESET() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserRESET, 0)
}

func (s *AltertblspcstmtContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *AltertblspcstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *AltertblspcstmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterAltertblspcstmt(s)
	}
}

func (s *AltertblspcstmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitAltertblspcstmt(s)
	}
}

func (s *AltertblspcstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitAltertblspcstmt(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Altertblspcstmt() (localctx IAltertblspcstmtContext) {
	localctx = NewAltertblspcstmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 720, PostgreSQLParserRULE_altertblspcstmt)
	p.SetState(5917)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 309, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(5905)
			p.Match(PostgreSQLParserALTER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5906)
			p.Match(PostgreSQLParserTABLESPACE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5907)
			p.Name()
		}
		{
			p.SetState(5908)
			p.Match(PostgreSQLParserSET)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5909)
			p.Reloptions()
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(5911)
			p.Match(PostgreSQLParserALTER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5912)
			p.Match(PostgreSQLParserTABLESPACE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5913)
			p.Name()
		}
		{
			p.SetState(5914)
			p.Match(PostgreSQLParserRESET)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5915)
			p.Reloptions()
		}

	case antlr.ATNInvalidAltNumber:
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IRenamestmtContext is an interface to support dynamic dispatch.
type IRenamestmtContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	ALTER() antlr.TerminalNode
	AGGREGATE() antlr.TerminalNode
	Aggregate_with_argtypes() IAggregate_with_argtypesContext
	RENAME() antlr.TerminalNode
	TO() antlr.TerminalNode
	AllName() []INameContext
	Name(i int) INameContext
	COLLATION() antlr.TerminalNode
	Any_name() IAny_nameContext
	CONVERSION_P() antlr.TerminalNode
	DATABASE() antlr.TerminalNode
	DOMAIN_P() antlr.TerminalNode
	CONSTRAINT() antlr.TerminalNode
	FOREIGN() antlr.TerminalNode
	DATA_P() antlr.TerminalNode
	WRAPPER() antlr.TerminalNode
	FUNCTION() antlr.TerminalNode
	Function_with_argtypes() IFunction_with_argtypesContext
	GROUP_P() antlr.TerminalNode
	AllRoleid() []IRoleidContext
	Roleid(i int) IRoleidContext
	Opt_procedural() IOpt_proceduralContext
	LANGUAGE() antlr.TerminalNode
	OPERATOR() antlr.TerminalNode
	CLASS() antlr.TerminalNode
	USING() antlr.TerminalNode
	FAMILY() antlr.TerminalNode
	POLICY() antlr.TerminalNode
	ON() antlr.TerminalNode
	Qualified_name() IQualified_nameContext
	IF_P() antlr.TerminalNode
	EXISTS() antlr.TerminalNode
	PROCEDURE() antlr.TerminalNode
	PUBLICATION() antlr.TerminalNode
	ROUTINE() antlr.TerminalNode
	SCHEMA() antlr.TerminalNode
	SERVER() antlr.TerminalNode
	SUBSCRIPTION() antlr.TerminalNode
	TABLE() antlr.TerminalNode
	Relation_expr() IRelation_exprContext
	SEQUENCE() antlr.TerminalNode
	VIEW() antlr.TerminalNode
	MATERIALIZED() antlr.TerminalNode
	INDEX() antlr.TerminalNode
	Opt_column() IOpt_columnContext
	RULE() antlr.TerminalNode
	TRIGGER() antlr.TerminalNode
	EVENT() antlr.TerminalNode
	ROLE() antlr.TerminalNode
	USER() antlr.TerminalNode
	TABLESPACE() antlr.TerminalNode
	STATISTICS() antlr.TerminalNode
	TEXT_P() antlr.TerminalNode
	SEARCH() antlr.TerminalNode
	PARSER() antlr.TerminalNode
	DICTIONARY() antlr.TerminalNode
	TEMPLATE() antlr.TerminalNode
	CONFIGURATION() antlr.TerminalNode
	TYPE_P() antlr.TerminalNode
	ATTRIBUTE() antlr.TerminalNode
	Opt_drop_behavior() IOpt_drop_behaviorContext

	// IsRenamestmtContext differentiates from other interfaces.
	IsRenamestmtContext()
}

type RenamestmtContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyRenamestmtContext() *RenamestmtContext {
	var p = new(RenamestmtContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_renamestmt
	return p
}

func InitEmptyRenamestmtContext(p *RenamestmtContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_renamestmt
}

func (*RenamestmtContext) IsRenamestmtContext() {}

func NewRenamestmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *RenamestmtContext {
	var p = new(RenamestmtContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_renamestmt

	return p
}

func (s *RenamestmtContext) GetParser() antlr.Parser { return s.parser }

func (s *RenamestmtContext) ALTER() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserALTER, 0)
}

func (s *RenamestmtContext) AGGREGATE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserAGGREGATE, 0)
}

func (s *RenamestmtContext) Aggregate_with_argtypes() IAggregate_with_argtypesContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IAggregate_with_argtypesContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IAggregate_with_argtypesContext)
}

func (s *RenamestmtContext) RENAME() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserRENAME, 0)
}

func (s *RenamestmtContext) TO() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserTO, 0)
}

func (s *RenamestmtContext) AllName() []INameContext {
	children := s.GetChildren()
	len := 0
	for _, ctx := range children {
		if _, ok := ctx.(INameContext); ok {
			len++
		}
	}

	tst := make([]INameContext, len)
	i := 0
	for _, ctx := range children {
		if t, ok := ctx.(INameContext); ok {
			tst[i] = t.(INameContext)
			i++
		}
	}

	return tst
}

func (s *RenamestmtContext) Name(i int) INameContext {
	var t antlr.RuleContext
	j := 0
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(INameContext); ok {
			if j == i {
				t = ctx.(antlr.RuleContext)
				break
			}
			j++
		}
	}

	if t == nil {
		return nil
	}

	return t.(INameContext)
}

func (s *RenamestmtContext) COLLATION() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCOLLATION, 0)
}

func (s *RenamestmtContext) Any_name() IAny_nameContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IAny_nameContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IAny_nameContext)
}

func (s *RenamestmtContext) CONVERSION_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCONVERSION_P, 0)
}

func (s *RenamestmtContext) DATABASE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserDATABASE, 0)
}

func (s *RenamestmtContext) DOMAIN_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserDOMAIN_P, 0)
}

func (s *RenamestmtContext) CONSTRAINT() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCONSTRAINT, 0)
}

func (s *RenamestmtContext) FOREIGN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserFOREIGN, 0)
}

func (s *RenamestmtContext) DATA_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserDATA_P, 0)
}

func (s *RenamestmtContext) WRAPPER() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserWRAPPER, 0)
}

func (s *RenamestmtContext) FUNCTION() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserFUNCTION, 0)
}

func (s *RenamestmtContext) Function_with_argtypes() IFunction_with_argtypesContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IFunction_with_argtypesContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IFunction_with_argtypesContext)
}

func (s *RenamestmtContext) GROUP_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserGROUP_P, 0)
}

func (s *RenamestmtContext) AllRoleid() []IRoleidContext {
	children := s.GetChildren()
	len := 0
	for _, ctx := range children {
		if _, ok := ctx.(IRoleidContext); ok {
			len++
		}
	}

	tst := make([]IRoleidContext, len)
	i := 0
	for _, ctx := range children {
		if t, ok := ctx.(IRoleidContext); ok {
			tst[i] = t.(IRoleidContext)
			i++
		}
	}

	return tst
}

func (s *RenamestmtContext) Roleid(i int) IRoleidContext {
	var t antlr.RuleContext
	j := 0
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IRoleidContext); ok {
			if j == i {
				t = ctx.(antlr.RuleContext)
				break
			}
			j++
		}
	}

	if t == nil {
		return nil
	}

	return t.(IRoleidContext)
}

func (s *RenamestmtContext) Opt_procedural() IOpt_proceduralContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOpt_proceduralContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOpt_proceduralContext)
}

func (s *RenamestmtContext) LANGUAGE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserLANGUAGE, 0)
}

func (s *RenamestmtContext) OPERATOR() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserOPERATOR, 0)
}

func (s *RenamestmtContext) CLASS() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCLASS, 0)
}

func (s *RenamestmtContext) USING() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserUSING, 0)
}

func (s *RenamestmtContext) FAMILY() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserFAMILY, 0)
}

func (s *RenamestmtContext) POLICY() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserPOLICY, 0)
}

func (s *RenamestmtContext) ON() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserON, 0)
}

func (s *RenamestmtContext) Qualified_name() IQualified_nameContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IQualified_nameContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IQualified_nameContext)
}

func (s *RenamestmtContext) IF_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserIF_P, 0)
}

func (s *RenamestmtContext) EXISTS() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserEXISTS, 0)
}

func (s *RenamestmtContext) PROCEDURE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserPROCEDURE, 0)
}

func (s *RenamestmtContext) PUBLICATION() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserPUBLICATION, 0)
}

func (s *RenamestmtContext) ROUTINE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserROUTINE, 0)
}

func (s *RenamestmtContext) SCHEMA() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserSCHEMA, 0)
}

func (s *RenamestmtContext) SERVER() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserSERVER, 0)
}

func (s *RenamestmtContext) SUBSCRIPTION() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserSUBSCRIPTION, 0)
}

func (s *RenamestmtContext) TABLE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserTABLE, 0)
}

func (s *RenamestmtContext) Relation_expr() IRelation_exprContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IRelation_exprContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IRelation_exprContext)
}

func (s *RenamestmtContext) SEQUENCE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserSEQUENCE, 0)
}

func (s *RenamestmtContext) VIEW() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserVIEW, 0)
}

func (s *RenamestmtContext) MATERIALIZED() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserMATERIALIZED, 0)
}

func (s *RenamestmtContext) INDEX() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserINDEX, 0)
}

func (s *RenamestmtContext) Opt_column() IOpt_columnContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOpt_columnContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOpt_columnContext)
}

func (s *RenamestmtContext) RULE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserRULE, 0)
}

func (s *RenamestmtContext) TRIGGER() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserTRIGGER, 0)
}

func (s *RenamestmtContext) EVENT() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserEVENT, 0)
}

func (s *RenamestmtContext) ROLE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserROLE, 0)
}

func (s *RenamestmtContext) USER() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserUSER, 0)
}

func (s *RenamestmtContext) TABLESPACE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserTABLESPACE, 0)
}

func (s *RenamestmtContext) STATISTICS() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserSTATISTICS, 0)
}

func (s *RenamestmtContext) TEXT_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserTEXT_P, 0)
}

func (s *RenamestmtContext) SEARCH() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserSEARCH, 0)
}

func (s *RenamestmtContext) PARSER() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserPARSER, 0)
}

func (s *RenamestmtContext) DICTIONARY() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserDICTIONARY, 0)
}

func (s *RenamestmtContext) TEMPLATE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserTEMPLATE, 0)
}

func (s *RenamestmtContext) CONFIGURATION() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCONFIGURATION, 0)
}

func (s *RenamestmtContext) TYPE_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserTYPE_P, 0)
}

func (s *RenamestmtContext) ATTRIBUTE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserATTRIBUTE, 0)
}

func (s *RenamestmtContext) Opt_drop_behavior() IOpt_drop_behaviorContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOpt_drop_behaviorContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOpt_drop_behaviorContext)
}

func (s *RenamestmtContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *RenamestmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *RenamestmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterRenamestmt(s)
	}
}

func (s *RenamestmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitRenamestmt(s)
	}
}

func (s *RenamestmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitRenamestmt(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Renamestmt() (localctx IRenamestmtContext) {
	localctx = NewRenamestmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 722, PostgreSQLParserRULE_renamestmt)
	p.SetState(6387)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 310, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(5919)
			p.Match(PostgreSQLParserALTER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5920)
			p.Match(PostgreSQLParserAGGREGATE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5921)
			p.Aggregate_with_argtypes()
		}
		{
			p.SetState(5922)
			p.Match(PostgreSQLParserRENAME)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5923)
			p.Match(PostgreSQLParserTO)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5924)
			p.Name()
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(5926)
			p.Match(PostgreSQLParserALTER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5927)
			p.Match(PostgreSQLParserCOLLATION)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5928)
			p.Any_name()
		}
		{
			p.SetState(5929)
			p.Match(PostgreSQLParserRENAME)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5930)
			p.Match(PostgreSQLParserTO)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5931)
			p.Name()
		}

	case 3:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(5933)
			p.Match(PostgreSQLParserALTER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5934)
			p.Match(PostgreSQLParserCONVERSION_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5935)
			p.Any_name()
		}
		{
			p.SetState(5936)
			p.Match(PostgreSQLParserRENAME)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5937)
			p.Match(PostgreSQLParserTO)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5938)
			p.Name()
		}

	case 4:
		p.EnterOuterAlt(localctx, 4)
		{
			p.SetState(5940)
			p.Match(PostgreSQLParserALTER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5941)
			p.Match(PostgreSQLParserDATABASE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5942)
			p.Name()
		}
		{
			p.SetState(5943)
			p.Match(PostgreSQLParserRENAME)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5944)
			p.Match(PostgreSQLParserTO)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5945)
			p.Name()
		}

	case 5:
		p.EnterOuterAlt(localctx, 5)
		{
			p.SetState(5947)
			p.Match(PostgreSQLParserALTER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5948)
			p.Match(PostgreSQLParserDOMAIN_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5949)
			p.Any_name()
		}
		{
			p.SetState(5950)
			p.Match(PostgreSQLParserRENAME)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5951)
			p.Match(PostgreSQLParserTO)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5952)
			p.Name()
		}

	case 6:
		p.EnterOuterAlt(localctx, 6)
		{
			p.SetState(5954)
			p.Match(PostgreSQLParserALTER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5955)
			p.Match(PostgreSQLParserDOMAIN_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5956)
			p.Any_name()
		}
		{
			p.SetState(5957)
			p.Match(PostgreSQLParserRENAME)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5958)
			p.Match(PostgreSQLParserCONSTRAINT)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5959)
			p.Name()
		}
		{
			p.SetState(5960)
			p.Match(PostgreSQLParserTO)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5961)
			p.Name()
		}

	case 7:
		p.EnterOuterAlt(localctx, 7)
		{
			p.SetState(5963)
			p.Match(PostgreSQLParserALTER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5964)
			p.Match(PostgreSQLParserFOREIGN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5965)
			p.Match(PostgreSQLParserDATA_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5966)
			p.Match(PostgreSQLParserWRAPPER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5967)
			p.Name()
		}
		{
			p.SetState(5968)
			p.Match(PostgreSQLParserRENAME)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5969)
			p.Match(PostgreSQLParserTO)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5970)
			p.Name()
		}

	case 8:
		p.EnterOuterAlt(localctx, 8)
		{
			p.SetState(5972)
			p.Match(PostgreSQLParserALTER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5973)
			p.Match(PostgreSQLParserFUNCTION)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5974)
			p.Function_with_argtypes()
		}
		{
			p.SetState(5975)
			p.Match(PostgreSQLParserRENAME)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5976)
			p.Match(PostgreSQLParserTO)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5977)
			p.Name()
		}

	case 9:
		p.EnterOuterAlt(localctx, 9)
		{
			p.SetState(5979)
			p.Match(PostgreSQLParserALTER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5980)
			p.Match(PostgreSQLParserGROUP_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5981)
			p.Roleid()
		}
		{
			p.SetState(5982)
			p.Match(PostgreSQLParserRENAME)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5983)
			p.Match(PostgreSQLParserTO)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5984)
			p.Roleid()
		}

	case 10:
		p.EnterOuterAlt(localctx, 10)
		{
			p.SetState(5986)
			p.Match(PostgreSQLParserALTER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5987)
			p.Opt_procedural()
		}
		{
			p.SetState(5988)
			p.Match(PostgreSQLParserLANGUAGE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5989)
			p.Name()
		}
		{
			p.SetState(5990)
			p.Match(PostgreSQLParserRENAME)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5991)
			p.Match(PostgreSQLParserTO)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5992)
			p.Name()
		}

	case 11:
		p.EnterOuterAlt(localctx, 11)
		{
			p.SetState(5994)
			p.Match(PostgreSQLParserALTER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5995)
			p.Match(PostgreSQLParserOPERATOR)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5996)
			p.Match(PostgreSQLParserCLASS)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5997)
			p.Any_name()
		}
		{
			p.SetState(5998)
			p.Match(PostgreSQLParserUSING)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(5999)
			p.Name()
		}
		{
			p.SetState(6000)
			p.Match(PostgreSQLParserRENAME)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6001)
			p.Match(PostgreSQLParserTO)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6002)
			p.Name()
		}

	case 12:
		p.EnterOuterAlt(localctx, 12)
		{
			p.SetState(6004)
			p.Match(PostgreSQLParserALTER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6005)
			p.Match(PostgreSQLParserOPERATOR)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6006)
			p.Match(PostgreSQLParserFAMILY)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6007)
			p.Any_name()
		}
		{
			p.SetState(6008)
			p.Match(PostgreSQLParserUSING)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6009)
			p.Name()
		}
		{
			p.SetState(6010)
			p.Match(PostgreSQLParserRENAME)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6011)
			p.Match(PostgreSQLParserTO)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6012)
			p.Name()
		}

	case 13:
		p.EnterOuterAlt(localctx, 13)
		{
			p.SetState(6014)
			p.Match(PostgreSQLParserALTER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6015)
			p.Match(PostgreSQLParserPOLICY)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6016)
			p.Name()
		}
		{
			p.SetState(6017)
			p.Match(PostgreSQLParserON)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6018)
			p.Qualified_name()
		}
		{
			p.SetState(6019)
			p.Match(PostgreSQLParserRENAME)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6020)
			p.Match(PostgreSQLParserTO)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6021)
			p.Name()
		}

	case 14:
		p.EnterOuterAlt(localctx, 14)
		{
			p.SetState(6023)
			p.Match(PostgreSQLParserALTER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6024)
			p.Match(PostgreSQLParserPOLICY)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6025)
			p.Match(PostgreSQLParserIF_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6026)
			p.Match(PostgreSQLParserEXISTS)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6027)
			p.Name()
		}
		{
			p.SetState(6028)
			p.Match(PostgreSQLParserON)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6029)
			p.Qualified_name()
		}
		{
			p.SetState(6030)
			p.Match(PostgreSQLParserRENAME)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6031)
			p.Match(PostgreSQLParserTO)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6032)
			p.Name()
		}

	case 15:
		p.EnterOuterAlt(localctx, 15)
		{
			p.SetState(6034)
			p.Match(PostgreSQLParserALTER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6035)
			p.Match(PostgreSQLParserPROCEDURE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6036)
			p.Function_with_argtypes()
		}
		{
			p.SetState(6037)
			p.Match(PostgreSQLParserRENAME)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6038)
			p.Match(PostgreSQLParserTO)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6039)
			p.Name()
		}

	case 16:
		p.EnterOuterAlt(localctx, 16)
		{
			p.SetState(6041)
			p.Match(PostgreSQLParserALTER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6042)
			p.Match(PostgreSQLParserPUBLICATION)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6043)
			p.Name()
		}
		{
			p.SetState(6044)
			p.Match(PostgreSQLParserRENAME)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6045)
			p.Match(PostgreSQLParserTO)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6046)
			p.Name()
		}

	case 17:
		p.EnterOuterAlt(localctx, 17)
		{
			p.SetState(6048)
			p.Match(PostgreSQLParserALTER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6049)
			p.Match(PostgreSQLParserROUTINE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6050)
			p.Function_with_argtypes()
		}
		{
			p.SetState(6051)
			p.Match(PostgreSQLParserRENAME)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6052)
			p.Match(PostgreSQLParserTO)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6053)
			p.Name()
		}

	case 18:
		p.EnterOuterAlt(localctx, 18)
		{
			p.SetState(6055)
			p.Match(PostgreSQLParserALTER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6056)
			p.Match(PostgreSQLParserSCHEMA)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6057)
			p.Name()
		}
		{
			p.SetState(6058)
			p.Match(PostgreSQLParserRENAME)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6059)
			p.Match(PostgreSQLParserTO)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6060)
			p.Name()
		}

	case 19:
		p.EnterOuterAlt(localctx, 19)
		{
			p.SetState(6062)
			p.Match(PostgreSQLParserALTER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6063)
			p.Match(PostgreSQLParserSERVER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6064)
			p.Name()
		}
		{
			p.SetState(6065)
			p.Match(PostgreSQLParserRENAME)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6066)
			p.Match(PostgreSQLParserTO)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6067)
			p.Name()
		}

	case 20:
		p.EnterOuterAlt(localctx, 20)
		{
			p.SetState(6069)
			p.Match(PostgreSQLParserALTER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6070)
			p.Match(PostgreSQLParserSUBSCRIPTION)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6071)
			p.Name()
		}
		{
			p.SetState(6072)
			p.Match(PostgreSQLParserRENAME)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6073)
			p.Match(PostgreSQLParserTO)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6074)
			p.Name()
		}

	case 21:
		p.EnterOuterAlt(localctx, 21)
		{
			p.SetState(6076)
			p.Match(PostgreSQLParserALTER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6077)
			p.Match(PostgreSQLParserTABLE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6078)
			p.Relation_expr()
		}
		{
			p.SetState(6079)
			p.Match(PostgreSQLParserRENAME)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6080)
			p.Match(PostgreSQLParserTO)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6081)
			p.Name()
		}

	case 22:
		p.EnterOuterAlt(localctx, 22)
		{
			p.SetState(6083)
			p.Match(PostgreSQLParserALTER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6084)
			p.Match(PostgreSQLParserTABLE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6085)
			p.Match(PostgreSQLParserIF_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6086)
			p.Match(PostgreSQLParserEXISTS)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6087)
			p.Relation_expr()
		}
		{
			p.SetState(6088)
			p.Match(PostgreSQLParserRENAME)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6089)
			p.Match(PostgreSQLParserTO)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6090)
			p.Name()
		}

	case 23:
		p.EnterOuterAlt(localctx, 23)
		{
			p.SetState(6092)
			p.Match(PostgreSQLParserALTER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6093)
			p.Match(PostgreSQLParserSEQUENCE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6094)
			p.Qualified_name()
		}
		{
			p.SetState(6095)
			p.Match(PostgreSQLParserRENAME)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6096)
			p.Match(PostgreSQLParserTO)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6097)
			p.Name()
		}

	case 24:
		p.EnterOuterAlt(localctx, 24)
		{
			p.SetState(6099)
			p.Match(PostgreSQLParserALTER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6100)
			p.Match(PostgreSQLParserSEQUENCE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6101)
			p.Match(PostgreSQLParserIF_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6102)
			p.Match(PostgreSQLParserEXISTS)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6103)
			p.Qualified_name()
		}
		{
			p.SetState(6104)
			p.Match(PostgreSQLParserRENAME)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6105)
			p.Match(PostgreSQLParserTO)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6106)
			p.Name()
		}

	case 25:
		p.EnterOuterAlt(localctx, 25)
		{
			p.SetState(6108)
			p.Match(PostgreSQLParserALTER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6109)
			p.Match(PostgreSQLParserVIEW)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6110)
			p.Qualified_name()
		}
		{
			p.SetState(6111)
			p.Match(PostgreSQLParserRENAME)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6112)
			p.Match(PostgreSQLParserTO)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6113)
			p.Name()
		}

	case 26:
		p.EnterOuterAlt(localctx, 26)
		{
			p.SetState(6115)
			p.Match(PostgreSQLParserALTER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6116)
			p.Match(PostgreSQLParserVIEW)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6117)
			p.Match(PostgreSQLParserIF_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6118)
			p.Match(PostgreSQLParserEXISTS)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6119)
			p.Qualified_name()
		}
		{
			p.SetState(6120)
			p.Match(PostgreSQLParserRENAME)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6121)
			p.Match(PostgreSQLParserTO)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6122)
			p.Name()
		}

	case 27:
		p.EnterOuterAlt(localctx, 27)
		{
			p.SetState(6124)
			p.Match(PostgreSQLParserALTER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6125)
			p.Match(PostgreSQLParserMATERIALIZED)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6126)
			p.Match(PostgreSQLParserVIEW)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6127)
			p.Qualified_name()
		}
		{
			p.SetState(6128)
			p.Match(PostgreSQLParserRENAME)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6129)
			p.Match(PostgreSQLParserTO)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6130)
			p.Name()
		}

	case 28:
		p.EnterOuterAlt(localctx, 28)
		{
			p.SetState(6132)
			p.Match(PostgreSQLParserALTER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6133)
			p.Match(PostgreSQLParserMATERIALIZED)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6134)
			p.Match(PostgreSQLParserVIEW)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6135)
			p.Match(PostgreSQLParserIF_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6136)
			p.Match(PostgreSQLParserEXISTS)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6137)
			p.Qualified_name()
		}
		{
			p.SetState(6138)
			p.Match(PostgreSQLParserRENAME)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6139)
			p.Match(PostgreSQLParserTO)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6140)
			p.Name()
		}

	case 29:
		p.EnterOuterAlt(localctx, 29)
		{
			p.SetState(6142)
			p.Match(PostgreSQLParserALTER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6143)
			p.Match(PostgreSQLParserINDEX)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6144)
			p.Qualified_name()
		}
		{
			p.SetState(6145)
			p.Match(PostgreSQLParserRENAME)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6146)
			p.Match(PostgreSQLParserTO)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6147)
			p.Name()
		}

	case 30:
		p.EnterOuterAlt(localctx, 30)
		{
			p.SetState(6149)
			p.Match(PostgreSQLParserALTER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6150)
			p.Match(PostgreSQLParserINDEX)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6151)
			p.Match(PostgreSQLParserIF_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6152)
			p.Match(PostgreSQLParserEXISTS)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6153)
			p.Qualified_name()
		}
		{
			p.SetState(6154)
			p.Match(PostgreSQLParserRENAME)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6155)
			p.Match(PostgreSQLParserTO)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6156)
			p.Name()
		}

	case 31:
		p.EnterOuterAlt(localctx, 31)
		{
			p.SetState(6158)
			p.Match(PostgreSQLParserALTER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6159)
			p.Match(PostgreSQLParserFOREIGN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6160)
			p.Match(PostgreSQLParserTABLE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6161)
			p.Relation_expr()
		}
		{
			p.SetState(6162)
			p.Match(PostgreSQLParserRENAME)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6163)
			p.Match(PostgreSQLParserTO)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6164)
			p.Name()
		}

	case 32:
		p.EnterOuterAlt(localctx, 32)
		{
			p.SetState(6166)
			p.Match(PostgreSQLParserALTER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6167)
			p.Match(PostgreSQLParserFOREIGN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6168)
			p.Match(PostgreSQLParserTABLE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6169)
			p.Match(PostgreSQLParserIF_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6170)
			p.Match(PostgreSQLParserEXISTS)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6171)
			p.Relation_expr()
		}
		{
			p.SetState(6172)
			p.Match(PostgreSQLParserRENAME)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6173)
			p.Match(PostgreSQLParserTO)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6174)
			p.Name()
		}

	case 33:
		p.EnterOuterAlt(localctx, 33)
		{
			p.SetState(6176)
			p.Match(PostgreSQLParserALTER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6177)
			p.Match(PostgreSQLParserTABLE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6178)
			p.Relation_expr()
		}
		{
			p.SetState(6179)
			p.Match(PostgreSQLParserRENAME)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6180)
			p.Opt_column()
		}
		{
			p.SetState(6181)
			p.Name()
		}
		{
			p.SetState(6182)
			p.Match(PostgreSQLParserTO)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6183)
			p.Name()
		}

	case 34:
		p.EnterOuterAlt(localctx, 34)
		{
			p.SetState(6185)
			p.Match(PostgreSQLParserALTER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6186)
			p.Match(PostgreSQLParserTABLE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6187)
			p.Match(PostgreSQLParserIF_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6188)
			p.Match(PostgreSQLParserEXISTS)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6189)
			p.Relation_expr()
		}
		{
			p.SetState(6190)
			p.Match(PostgreSQLParserRENAME)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6191)
			p.Opt_column()
		}
		{
			p.SetState(6192)
			p.Name()
		}
		{
			p.SetState(6193)
			p.Match(PostgreSQLParserTO)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6194)
			p.Name()
		}

	case 35:
		p.EnterOuterAlt(localctx, 35)
		{
			p.SetState(6196)
			p.Match(PostgreSQLParserALTER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6197)
			p.Match(PostgreSQLParserVIEW)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6198)
			p.Qualified_name()
		}
		{
			p.SetState(6199)
			p.Match(PostgreSQLParserRENAME)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6200)
			p.Opt_column()
		}
		{
			p.SetState(6201)
			p.Name()
		}
		{
			p.SetState(6202)
			p.Match(PostgreSQLParserTO)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6203)
			p.Name()
		}

	case 36:
		p.EnterOuterAlt(localctx, 36)
		{
			p.SetState(6205)
			p.Match(PostgreSQLParserALTER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6206)
			p.Match(PostgreSQLParserVIEW)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6207)
			p.Match(PostgreSQLParserIF_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6208)
			p.Match(PostgreSQLParserEXISTS)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6209)
			p.Qualified_name()
		}
		{
			p.SetState(6210)
			p.Match(PostgreSQLParserRENAME)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6211)
			p.Opt_column()
		}
		{
			p.SetState(6212)
			p.Name()
		}
		{
			p.SetState(6213)
			p.Match(PostgreSQLParserTO)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6214)
			p.Name()
		}

	case 37:
		p.EnterOuterAlt(localctx, 37)
		{
			p.SetState(6216)
			p.Match(PostgreSQLParserALTER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6217)
			p.Match(PostgreSQLParserMATERIALIZED)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6218)
			p.Match(PostgreSQLParserVIEW)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6219)
			p.Qualified_name()
		}
		{
			p.SetState(6220)
			p.Match(PostgreSQLParserRENAME)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6221)
			p.Opt_column()
		}
		{
			p.SetState(6222)
			p.Name()
		}
		{
			p.SetState(6223)
			p.Match(PostgreSQLParserTO)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6224)
			p.Name()
		}

	case 38:
		p.EnterOuterAlt(localctx, 38)
		{
			p.SetState(6226)
			p.Match(PostgreSQLParserALTER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6227)
			p.Match(PostgreSQLParserMATERIALIZED)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6228)
			p.Match(PostgreSQLParserVIEW)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6229)
			p.Match(PostgreSQLParserIF_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6230)
			p.Match(PostgreSQLParserEXISTS)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6231)
			p.Qualified_name()
		}
		{
			p.SetState(6232)
			p.Match(PostgreSQLParserRENAME)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6233)
			p.Opt_column()
		}
		{
			p.SetState(6234)
			p.Name()
		}
		{
			p.SetState(6235)
			p.Match(PostgreSQLParserTO)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6236)
			p.Name()
		}

	case 39:
		p.EnterOuterAlt(localctx, 39)
		{
			p.SetState(6238)
			p.Match(PostgreSQLParserALTER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6239)
			p.Match(PostgreSQLParserTABLE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6240)
			p.Relation_expr()
		}
		{
			p.SetState(6241)
			p.Match(PostgreSQLParserRENAME)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6242)
			p.Match(PostgreSQLParserCONSTRAINT)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6243)
			p.Name()
		}
		{
			p.SetState(6244)
			p.Match(PostgreSQLParserTO)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6245)
			p.Name()
		}

	case 40:
		p.EnterOuterAlt(localctx, 40)
		{
			p.SetState(6247)
			p.Match(PostgreSQLParserALTER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6248)
			p.Match(PostgreSQLParserTABLE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6249)
			p.Match(PostgreSQLParserIF_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6250)
			p.Match(PostgreSQLParserEXISTS)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6251)
			p.Relation_expr()
		}
		{
			p.SetState(6252)
			p.Match(PostgreSQLParserRENAME)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6253)
			p.Match(PostgreSQLParserCONSTRAINT)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6254)
			p.Name()
		}
		{
			p.SetState(6255)
			p.Match(PostgreSQLParserTO)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6256)
			p.Name()
		}

	case 41:
		p.EnterOuterAlt(localctx, 41)
		{
			p.SetState(6258)
			p.Match(PostgreSQLParserALTER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6259)
			p.Match(PostgreSQLParserFOREIGN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6260)
			p.Match(PostgreSQLParserTABLE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6261)
			p.Relation_expr()
		}
		{
			p.SetState(6262)
			p.Match(PostgreSQLParserRENAME)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6263)
			p.Opt_column()
		}
		{
			p.SetState(6264)
			p.Name()
		}
		{
			p.SetState(6265)
			p.Match(PostgreSQLParserTO)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6266)
			p.Name()
		}

	case 42:
		p.EnterOuterAlt(localctx, 42)
		{
			p.SetState(6268)
			p.Match(PostgreSQLParserALTER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6269)
			p.Match(PostgreSQLParserFOREIGN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6270)
			p.Match(PostgreSQLParserTABLE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6271)
			p.Match(PostgreSQLParserIF_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6272)
			p.Match(PostgreSQLParserEXISTS)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6273)
			p.Relation_expr()
		}
		{
			p.SetState(6274)
			p.Match(PostgreSQLParserRENAME)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6275)
			p.Opt_column()
		}
		{
			p.SetState(6276)
			p.Name()
		}
		{
			p.SetState(6277)
			p.Match(PostgreSQLParserTO)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6278)
			p.Name()
		}

	case 43:
		p.EnterOuterAlt(localctx, 43)
		{
			p.SetState(6280)
			p.Match(PostgreSQLParserALTER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6281)
			p.Match(PostgreSQLParserRULE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6282)
			p.Name()
		}
		{
			p.SetState(6283)
			p.Match(PostgreSQLParserON)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6284)
			p.Qualified_name()
		}
		{
			p.SetState(6285)
			p.Match(PostgreSQLParserRENAME)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6286)
			p.Match(PostgreSQLParserTO)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6287)
			p.Name()
		}

	case 44:
		p.EnterOuterAlt(localctx, 44)
		{
			p.SetState(6289)
			p.Match(PostgreSQLParserALTER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6290)
			p.Match(PostgreSQLParserTRIGGER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6291)
			p.Name()
		}
		{
			p.SetState(6292)
			p.Match(PostgreSQLParserON)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6293)
			p.Qualified_name()
		}
		{
			p.SetState(6294)
			p.Match(PostgreSQLParserRENAME)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6295)
			p.Match(PostgreSQLParserTO)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6296)
			p.Name()
		}

	case 45:
		p.EnterOuterAlt(localctx, 45)
		{
			p.SetState(6298)
			p.Match(PostgreSQLParserALTER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6299)
			p.Match(PostgreSQLParserEVENT)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6300)
			p.Match(PostgreSQLParserTRIGGER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6301)
			p.Name()
		}
		{
			p.SetState(6302)
			p.Match(PostgreSQLParserRENAME)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6303)
			p.Match(PostgreSQLParserTO)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6304)
			p.Name()
		}

	case 46:
		p.EnterOuterAlt(localctx, 46)
		{
			p.SetState(6306)
			p.Match(PostgreSQLParserALTER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6307)
			p.Match(PostgreSQLParserROLE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6308)
			p.Roleid()
		}
		{
			p.SetState(6309)
			p.Match(PostgreSQLParserRENAME)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6310)
			p.Match(PostgreSQLParserTO)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6311)
			p.Roleid()
		}

	case 47:
		p.EnterOuterAlt(localctx, 47)
		{
			p.SetState(6313)
			p.Match(PostgreSQLParserALTER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6314)
			p.Match(PostgreSQLParserUSER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6315)
			p.Roleid()
		}
		{
			p.SetState(6316)
			p.Match(PostgreSQLParserRENAME)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6317)
			p.Match(PostgreSQLParserTO)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6318)
			p.Roleid()
		}

	case 48:
		p.EnterOuterAlt(localctx, 48)
		{
			p.SetState(6320)
			p.Match(PostgreSQLParserALTER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6321)
			p.Match(PostgreSQLParserTABLESPACE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6322)
			p.Name()
		}
		{
			p.SetState(6323)
			p.Match(PostgreSQLParserRENAME)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6324)
			p.Match(PostgreSQLParserTO)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6325)
			p.Name()
		}

	case 49:
		p.EnterOuterAlt(localctx, 49)
		{
			p.SetState(6327)
			p.Match(PostgreSQLParserALTER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6328)
			p.Match(PostgreSQLParserSTATISTICS)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6329)
			p.Any_name()
		}
		{
			p.SetState(6330)
			p.Match(PostgreSQLParserRENAME)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6331)
			p.Match(PostgreSQLParserTO)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6332)
			p.Name()
		}

	case 50:
		p.EnterOuterAlt(localctx, 50)
		{
			p.SetState(6334)
			p.Match(PostgreSQLParserALTER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6335)
			p.Match(PostgreSQLParserTEXT_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6336)
			p.Match(PostgreSQLParserSEARCH)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6337)
			p.Match(PostgreSQLParserPARSER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6338)
			p.Any_name()
		}
		{
			p.SetState(6339)
			p.Match(PostgreSQLParserRENAME)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6340)
			p.Match(PostgreSQLParserTO)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6341)
			p.Name()
		}

	case 51:
		p.EnterOuterAlt(localctx, 51)
		{
			p.SetState(6343)
			p.Match(PostgreSQLParserALTER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6344)
			p.Match(PostgreSQLParserTEXT_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6345)
			p.Match(PostgreSQLParserSEARCH)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6346)
			p.Match(PostgreSQLParserDICTIONARY)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6347)
			p.Any_name()
		}
		{
			p.SetState(6348)
			p.Match(PostgreSQLParserRENAME)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6349)
			p.Match(PostgreSQLParserTO)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6350)
			p.Name()
		}

	case 52:
		p.EnterOuterAlt(localctx, 52)
		{
			p.SetState(6352)
			p.Match(PostgreSQLParserALTER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6353)
			p.Match(PostgreSQLParserTEXT_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6354)
			p.Match(PostgreSQLParserSEARCH)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6355)
			p.Match(PostgreSQLParserTEMPLATE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6356)
			p.Any_name()
		}
		{
			p.SetState(6357)
			p.Match(PostgreSQLParserRENAME)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6358)
			p.Match(PostgreSQLParserTO)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6359)
			p.Name()
		}

	case 53:
		p.EnterOuterAlt(localctx, 53)
		{
			p.SetState(6361)
			p.Match(PostgreSQLParserALTER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6362)
			p.Match(PostgreSQLParserTEXT_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6363)
			p.Match(PostgreSQLParserSEARCH)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6364)
			p.Match(PostgreSQLParserCONFIGURATION)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6365)
			p.Any_name()
		}
		{
			p.SetState(6366)
			p.Match(PostgreSQLParserRENAME)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6367)
			p.Match(PostgreSQLParserTO)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6368)
			p.Name()
		}

	case 54:
		p.EnterOuterAlt(localctx, 54)
		{
			p.SetState(6370)
			p.Match(PostgreSQLParserALTER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6371)
			p.Match(PostgreSQLParserTYPE_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6372)
			p.Any_name()
		}
		{
			p.SetState(6373)
			p.Match(PostgreSQLParserRENAME)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6374)
			p.Match(PostgreSQLParserTO)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6375)
			p.Name()
		}

	case 55:
		p.EnterOuterAlt(localctx, 55)
		{
			p.SetState(6377)
			p.Match(PostgreSQLParserALTER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6378)
			p.Match(PostgreSQLParserTYPE_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6379)
			p.Any_name()
		}
		{
			p.SetState(6380)
			p.Match(PostgreSQLParserRENAME)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6381)
			p.Match(PostgreSQLParserATTRIBUTE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6382)
			p.Name()
		}
		{
			p.SetState(6383)
			p.Match(PostgreSQLParserTO)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6384)
			p.Name()
		}
		{
			p.SetState(6385)
			p.Opt_drop_behavior()
		}

	case antlr.ATNInvalidAltNumber:
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IOpt_columnContext is an interface to support dynamic dispatch.
type IOpt_columnContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	COLUMN() antlr.TerminalNode

	// IsOpt_columnContext differentiates from other interfaces.
	IsOpt_columnContext()
}

type Opt_columnContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyOpt_columnContext() *Opt_columnContext {
	var p = new(Opt_columnContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opt_column
	return p
}

func InitEmptyOpt_columnContext(p *Opt_columnContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opt_column
}

func (*Opt_columnContext) IsOpt_columnContext() {}

func NewOpt_columnContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_columnContext {
	var p = new(Opt_columnContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_opt_column

	return p
}

func (s *Opt_columnContext) GetParser() antlr.Parser { return s.parser }

func (s *Opt_columnContext) COLUMN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCOLUMN, 0)
}

func (s *Opt_columnContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Opt_columnContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Opt_columnContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterOpt_column(s)
	}
}

func (s *Opt_columnContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitOpt_column(s)
	}
}

func (s *Opt_columnContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitOpt_column(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Opt_column() (localctx IOpt_columnContext) {
	localctx = NewOpt_columnContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 724, PostgreSQLParserRULE_opt_column)
	p.SetState(6391)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 311, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(6389)
			p.Match(PostgreSQLParserCOLUMN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)

	case antlr.ATNInvalidAltNumber:
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IOpt_set_dataContext is an interface to support dynamic dispatch.
type IOpt_set_dataContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	SET() antlr.TerminalNode
	DATA_P() antlr.TerminalNode

	// IsOpt_set_dataContext differentiates from other interfaces.
	IsOpt_set_dataContext()
}

type Opt_set_dataContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyOpt_set_dataContext() *Opt_set_dataContext {
	var p = new(Opt_set_dataContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opt_set_data
	return p
}

func InitEmptyOpt_set_dataContext(p *Opt_set_dataContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opt_set_data
}

func (*Opt_set_dataContext) IsOpt_set_dataContext() {}

func NewOpt_set_dataContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_set_dataContext {
	var p = new(Opt_set_dataContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_opt_set_data

	return p
}

func (s *Opt_set_dataContext) GetParser() antlr.Parser { return s.parser }

func (s *Opt_set_dataContext) SET() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserSET, 0)
}

func (s *Opt_set_dataContext) DATA_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserDATA_P, 0)
}

func (s *Opt_set_dataContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Opt_set_dataContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Opt_set_dataContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterOpt_set_data(s)
	}
}

func (s *Opt_set_dataContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitOpt_set_data(s)
	}
}

func (s *Opt_set_dataContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitOpt_set_data(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Opt_set_data() (localctx IOpt_set_dataContext) {
	localctx = NewOpt_set_dataContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 726, PostgreSQLParserRULE_opt_set_data)
	p.SetState(6396)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetTokenStream().LA(1) {
	case PostgreSQLParserSET:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(6393)
			p.Match(PostgreSQLParserSET)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6394)
			p.Match(PostgreSQLParserDATA_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case PostgreSQLParserTYPE_P:
		p.EnterOuterAlt(localctx, 2)

	default:
		p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IAlterobjectdependsstmtContext is an interface to support dynamic dispatch.
type IAlterobjectdependsstmtContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	ALTER() antlr.TerminalNode
	FUNCTION() antlr.TerminalNode
	Function_with_argtypes() IFunction_with_argtypesContext
	Opt_no() IOpt_noContext
	DEPENDS() antlr.TerminalNode
	AllON() []antlr.TerminalNode
	ON(i int) antlr.TerminalNode
	EXTENSION() antlr.TerminalNode
	AllName() []INameContext
	Name(i int) INameContext
	PROCEDURE() antlr.TerminalNode
	ROUTINE() antlr.TerminalNode
	TRIGGER() antlr.TerminalNode
	Qualified_name() IQualified_nameContext
	MATERIALIZED() antlr.TerminalNode
	VIEW() antlr.TerminalNode
	INDEX() antlr.TerminalNode

	// IsAlterobjectdependsstmtContext differentiates from other interfaces.
	IsAlterobjectdependsstmtContext()
}

type AlterobjectdependsstmtContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyAlterobjectdependsstmtContext() *AlterobjectdependsstmtContext {
	var p = new(AlterobjectdependsstmtContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_alterobjectdependsstmt
	return p
}

func InitEmptyAlterobjectdependsstmtContext(p *AlterobjectdependsstmtContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_alterobjectdependsstmt
}

func (*AlterobjectdependsstmtContext) IsAlterobjectdependsstmtContext() {}

func NewAlterobjectdependsstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AlterobjectdependsstmtContext {
	var p = new(AlterobjectdependsstmtContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_alterobjectdependsstmt

	return p
}

func (s *AlterobjectdependsstmtContext) GetParser() antlr.Parser { return s.parser }

func (s *AlterobjectdependsstmtContext) ALTER() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserALTER, 0)
}

func (s *AlterobjectdependsstmtContext) FUNCTION() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserFUNCTION, 0)
}

func (s *AlterobjectdependsstmtContext) Function_with_argtypes() IFunction_with_argtypesContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IFunction_with_argtypesContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IFunction_with_argtypesContext)
}

func (s *AlterobjectdependsstmtContext) Opt_no() IOpt_noContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOpt_noContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOpt_noContext)
}

func (s *AlterobjectdependsstmtContext) DEPENDS() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserDEPENDS, 0)
}

func (s *AlterobjectdependsstmtContext) AllON() []antlr.TerminalNode {
	return s.GetTokens(PostgreSQLParserON)
}

func (s *AlterobjectdependsstmtContext) ON(i int) antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserON, i)
}

func (s *AlterobjectdependsstmtContext) EXTENSION() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserEXTENSION, 0)
}

func (s *AlterobjectdependsstmtContext) AllName() []INameContext {
	children := s.GetChildren()
	len := 0
	for _, ctx := range children {
		if _, ok := ctx.(INameContext); ok {
			len++
		}
	}

	tst := make([]INameContext, len)
	i := 0
	for _, ctx := range children {
		if t, ok := ctx.(INameContext); ok {
			tst[i] = t.(INameContext)
			i++
		}
	}

	return tst
}

func (s *AlterobjectdependsstmtContext) Name(i int) INameContext {
	var t antlr.RuleContext
	j := 0
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(INameContext); ok {
			if j == i {
				t = ctx.(antlr.RuleContext)
				break
			}
			j++
		}
	}

	if t == nil {
		return nil
	}

	return t.(INameContext)
}

func (s *AlterobjectdependsstmtContext) PROCEDURE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserPROCEDURE, 0)
}

func (s *AlterobjectdependsstmtContext) ROUTINE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserROUTINE, 0)
}

func (s *AlterobjectdependsstmtContext) TRIGGER() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserTRIGGER, 0)
}

func (s *AlterobjectdependsstmtContext) Qualified_name() IQualified_nameContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IQualified_nameContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IQualified_nameContext)
}

func (s *AlterobjectdependsstmtContext) MATERIALIZED() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserMATERIALIZED, 0)
}

func (s *AlterobjectdependsstmtContext) VIEW() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserVIEW, 0)
}

func (s *AlterobjectdependsstmtContext) INDEX() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserINDEX, 0)
}

func (s *AlterobjectdependsstmtContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *AlterobjectdependsstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *AlterobjectdependsstmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterAlterobjectdependsstmt(s)
	}
}

func (s *AlterobjectdependsstmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitAlterobjectdependsstmt(s)
	}
}

func (s *AlterobjectdependsstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitAlterobjectdependsstmt(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Alterobjectdependsstmt() (localctx IAlterobjectdependsstmtContext) {
	localctx = NewAlterobjectdependsstmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 728, PostgreSQLParserRULE_alterobjectdependsstmt)
	p.SetState(6455)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 313, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(6398)
			p.Match(PostgreSQLParserALTER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6399)
			p.Match(PostgreSQLParserFUNCTION)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6400)
			p.Function_with_argtypes()
		}
		{
			p.SetState(6401)
			p.Opt_no()
		}
		{
			p.SetState(6402)
			p.Match(PostgreSQLParserDEPENDS)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6403)
			p.Match(PostgreSQLParserON)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6404)
			p.Match(PostgreSQLParserEXTENSION)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6405)
			p.Name()
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(6407)
			p.Match(PostgreSQLParserALTER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6408)
			p.Match(PostgreSQLParserPROCEDURE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6409)
			p.Function_with_argtypes()
		}
		{
			p.SetState(6410)
			p.Opt_no()
		}
		{
			p.SetState(6411)
			p.Match(PostgreSQLParserDEPENDS)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6412)
			p.Match(PostgreSQLParserON)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6413)
			p.Match(PostgreSQLParserEXTENSION)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6414)
			p.Name()
		}

	case 3:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(6416)
			p.Match(PostgreSQLParserALTER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6417)
			p.Match(PostgreSQLParserROUTINE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6418)
			p.Function_with_argtypes()
		}
		{
			p.SetState(6419)
			p.Opt_no()
		}
		{
			p.SetState(6420)
			p.Match(PostgreSQLParserDEPENDS)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6421)
			p.Match(PostgreSQLParserON)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6422)
			p.Match(PostgreSQLParserEXTENSION)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6423)
			p.Name()
		}

	case 4:
		p.EnterOuterAlt(localctx, 4)
		{
			p.SetState(6425)
			p.Match(PostgreSQLParserALTER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6426)
			p.Match(PostgreSQLParserTRIGGER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6427)
			p.Name()
		}
		{
			p.SetState(6428)
			p.Match(PostgreSQLParserON)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6429)
			p.Qualified_name()
		}
		{
			p.SetState(6430)
			p.Opt_no()
		}
		{
			p.SetState(6431)
			p.Match(PostgreSQLParserDEPENDS)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6432)
			p.Match(PostgreSQLParserON)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6433)
			p.Match(PostgreSQLParserEXTENSION)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6434)
			p.Name()
		}

	case 5:
		p.EnterOuterAlt(localctx, 5)
		{
			p.SetState(6436)
			p.Match(PostgreSQLParserALTER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6437)
			p.Match(PostgreSQLParserMATERIALIZED)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6438)
			p.Match(PostgreSQLParserVIEW)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6439)
			p.Qualified_name()
		}
		{
			p.SetState(6440)
			p.Opt_no()
		}
		{
			p.SetState(6441)
			p.Match(PostgreSQLParserDEPENDS)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6442)
			p.Match(PostgreSQLParserON)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6443)
			p.Match(PostgreSQLParserEXTENSION)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6444)
			p.Name()
		}

	case 6:
		p.EnterOuterAlt(localctx, 6)
		{
			p.SetState(6446)
			p.Match(PostgreSQLParserALTER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6447)
			p.Match(PostgreSQLParserINDEX)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6448)
			p.Qualified_name()
		}
		{
			p.SetState(6449)
			p.Opt_no()
		}
		{
			p.SetState(6450)
			p.Match(PostgreSQLParserDEPENDS)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6451)
			p.Match(PostgreSQLParserON)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6452)
			p.Match(PostgreSQLParserEXTENSION)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6453)
			p.Name()
		}

	case antlr.ATNInvalidAltNumber:
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IOpt_noContext is an interface to support dynamic dispatch.
type IOpt_noContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	NO() antlr.TerminalNode

	// IsOpt_noContext differentiates from other interfaces.
	IsOpt_noContext()
}

type Opt_noContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyOpt_noContext() *Opt_noContext {
	var p = new(Opt_noContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opt_no
	return p
}

func InitEmptyOpt_noContext(p *Opt_noContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opt_no
}

func (*Opt_noContext) IsOpt_noContext() {}

func NewOpt_noContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_noContext {
	var p = new(Opt_noContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_opt_no

	return p
}

func (s *Opt_noContext) GetParser() antlr.Parser { return s.parser }

func (s *Opt_noContext) NO() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserNO, 0)
}

func (s *Opt_noContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Opt_noContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Opt_noContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterOpt_no(s)
	}
}

func (s *Opt_noContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitOpt_no(s)
	}
}

func (s *Opt_noContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitOpt_no(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Opt_no() (localctx IOpt_noContext) {
	localctx = NewOpt_noContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 730, PostgreSQLParserRULE_opt_no)
	p.SetState(6459)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetTokenStream().LA(1) {
	case PostgreSQLParserNO:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(6457)
			p.Match(PostgreSQLParserNO)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case PostgreSQLParserDEPENDS:
		p.EnterOuterAlt(localctx, 2)

	default:
		p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IAlterobjectschemastmtContext is an interface to support dynamic dispatch.
type IAlterobjectschemastmtContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	ALTER() antlr.TerminalNode
	AGGREGATE() antlr.TerminalNode
	Aggregate_with_argtypes() IAggregate_with_argtypesContext
	SET() antlr.TerminalNode
	SCHEMA() antlr.TerminalNode
	AllName() []INameContext
	Name(i int) INameContext
	COLLATION() antlr.TerminalNode
	Any_name() IAny_nameContext
	CONVERSION_P() antlr.TerminalNode
	DOMAIN_P() antlr.TerminalNode
	EXTENSION() antlr.TerminalNode
	FUNCTION() antlr.TerminalNode
	Function_with_argtypes() IFunction_with_argtypesContext
	OPERATOR() antlr.TerminalNode
	Operator_with_argtypes() IOperator_with_argtypesContext
	CLASS() antlr.TerminalNode
	USING() antlr.TerminalNode
	FAMILY() antlr.TerminalNode
	PROCEDURE() antlr.TerminalNode
	ROUTINE() antlr.TerminalNode
	TABLE() antlr.TerminalNode
	Relation_expr() IRelation_exprContext
	IF_P() antlr.TerminalNode
	EXISTS() antlr.TerminalNode
	STATISTICS() antlr.TerminalNode
	TEXT_P() antlr.TerminalNode
	SEARCH() antlr.TerminalNode
	PARSER() antlr.TerminalNode
	DICTIONARY() antlr.TerminalNode
	TEMPLATE() antlr.TerminalNode
	CONFIGURATION() antlr.TerminalNode
	SEQUENCE() antlr.TerminalNode
	Qualified_name() IQualified_nameContext
	VIEW() antlr.TerminalNode
	MATERIALIZED() antlr.TerminalNode
	FOREIGN() antlr.TerminalNode
	TYPE_P() antlr.TerminalNode

	// IsAlterobjectschemastmtContext differentiates from other interfaces.
	IsAlterobjectschemastmtContext()
}

type AlterobjectschemastmtContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyAlterobjectschemastmtContext() *AlterobjectschemastmtContext {
	var p = new(AlterobjectschemastmtContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_alterobjectschemastmt
	return p
}

func InitEmptyAlterobjectschemastmtContext(p *AlterobjectschemastmtContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_alterobjectschemastmt
}

func (*AlterobjectschemastmtContext) IsAlterobjectschemastmtContext() {}

func NewAlterobjectschemastmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AlterobjectschemastmtContext {
	var p = new(AlterobjectschemastmtContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_alterobjectschemastmt

	return p
}

func (s *AlterobjectschemastmtContext) GetParser() antlr.Parser { return s.parser }

func (s *AlterobjectschemastmtContext) ALTER() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserALTER, 0)
}

func (s *AlterobjectschemastmtContext) AGGREGATE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserAGGREGATE, 0)
}

func (s *AlterobjectschemastmtContext) Aggregate_with_argtypes() IAggregate_with_argtypesContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IAggregate_with_argtypesContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IAggregate_with_argtypesContext)
}

func (s *AlterobjectschemastmtContext) SET() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserSET, 0)
}

func (s *AlterobjectschemastmtContext) SCHEMA() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserSCHEMA, 0)
}

func (s *AlterobjectschemastmtContext) AllName() []INameContext {
	children := s.GetChildren()
	len := 0
	for _, ctx := range children {
		if _, ok := ctx.(INameContext); ok {
			len++
		}
	}

	tst := make([]INameContext, len)
	i := 0
	for _, ctx := range children {
		if t, ok := ctx.(INameContext); ok {
			tst[i] = t.(INameContext)
			i++
		}
	}

	return tst
}

func (s *AlterobjectschemastmtContext) Name(i int) INameContext {
	var t antlr.RuleContext
	j := 0
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(INameContext); ok {
			if j == i {
				t = ctx.(antlr.RuleContext)
				break
			}
			j++
		}
	}

	if t == nil {
		return nil
	}

	return t.(INameContext)
}

func (s *AlterobjectschemastmtContext) COLLATION() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCOLLATION, 0)
}

func (s *AlterobjectschemastmtContext) Any_name() IAny_nameContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IAny_nameContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IAny_nameContext)
}

func (s *AlterobjectschemastmtContext) CONVERSION_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCONVERSION_P, 0)
}

func (s *AlterobjectschemastmtContext) DOMAIN_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserDOMAIN_P, 0)
}

func (s *AlterobjectschemastmtContext) EXTENSION() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserEXTENSION, 0)
}

func (s *AlterobjectschemastmtContext) FUNCTION() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserFUNCTION, 0)
}

func (s *AlterobjectschemastmtContext) Function_with_argtypes() IFunction_with_argtypesContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IFunction_with_argtypesContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IFunction_with_argtypesContext)
}

func (s *AlterobjectschemastmtContext) OPERATOR() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserOPERATOR, 0)
}

func (s *AlterobjectschemastmtContext) Operator_with_argtypes() IOperator_with_argtypesContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOperator_with_argtypesContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOperator_with_argtypesContext)
}

func (s *AlterobjectschemastmtContext) CLASS() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCLASS, 0)
}

func (s *AlterobjectschemastmtContext) USING() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserUSING, 0)
}

func (s *AlterobjectschemastmtContext) FAMILY() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserFAMILY, 0)
}

func (s *AlterobjectschemastmtContext) PROCEDURE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserPROCEDURE, 0)
}

func (s *AlterobjectschemastmtContext) ROUTINE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserROUTINE, 0)
}

func (s *AlterobjectschemastmtContext) TABLE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserTABLE, 0)
}

func (s *AlterobjectschemastmtContext) Relation_expr() IRelation_exprContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IRelation_exprContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IRelation_exprContext)
}

func (s *AlterobjectschemastmtContext) IF_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserIF_P, 0)
}

func (s *AlterobjectschemastmtContext) EXISTS() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserEXISTS, 0)
}

func (s *AlterobjectschemastmtContext) STATISTICS() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserSTATISTICS, 0)
}

func (s *AlterobjectschemastmtContext) TEXT_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserTEXT_P, 0)
}

func (s *AlterobjectschemastmtContext) SEARCH() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserSEARCH, 0)
}

func (s *AlterobjectschemastmtContext) PARSER() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserPARSER, 0)
}

func (s *AlterobjectschemastmtContext) DICTIONARY() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserDICTIONARY, 0)
}

func (s *AlterobjectschemastmtContext) TEMPLATE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserTEMPLATE, 0)
}

func (s *AlterobjectschemastmtContext) CONFIGURATION() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCONFIGURATION, 0)
}

func (s *AlterobjectschemastmtContext) SEQUENCE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserSEQUENCE, 0)
}

func (s *AlterobjectschemastmtContext) Qualified_name() IQualified_nameContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IQualified_nameContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IQualified_nameContext)
}

func (s *AlterobjectschemastmtContext) VIEW() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserVIEW, 0)
}

func (s *AlterobjectschemastmtContext) MATERIALIZED() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserMATERIALIZED, 0)
}

func (s *AlterobjectschemastmtContext) FOREIGN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserFOREIGN, 0)
}

func (s *AlterobjectschemastmtContext) TYPE_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserTYPE_P, 0)
}

func (s *AlterobjectschemastmtContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *AlterobjectschemastmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *AlterobjectschemastmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterAlterobjectschemastmt(s)
	}
}

func (s *AlterobjectschemastmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitAlterobjectschemastmt(s)
	}
}

func (s *AlterobjectschemastmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitAlterobjectschemastmt(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Alterobjectschemastmt() (localctx IAlterobjectschemastmtContext) {
	localctx = NewAlterobjectschemastmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 732, PostgreSQLParserRULE_alterobjectschemastmt)
	p.SetState(6678)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 315, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(6461)
			p.Match(PostgreSQLParserALTER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6462)
			p.Match(PostgreSQLParserAGGREGATE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6463)
			p.Aggregate_with_argtypes()
		}
		{
			p.SetState(6464)
			p.Match(PostgreSQLParserSET)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6465)
			p.Match(PostgreSQLParserSCHEMA)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6466)
			p.Name()
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(6468)
			p.Match(PostgreSQLParserALTER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6469)
			p.Match(PostgreSQLParserCOLLATION)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6470)
			p.Any_name()
		}
		{
			p.SetState(6471)
			p.Match(PostgreSQLParserSET)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6472)
			p.Match(PostgreSQLParserSCHEMA)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6473)
			p.Name()
		}

	case 3:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(6475)
			p.Match(PostgreSQLParserALTER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6476)
			p.Match(PostgreSQLParserCONVERSION_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6477)
			p.Any_name()
		}
		{
			p.SetState(6478)
			p.Match(PostgreSQLParserSET)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6479)
			p.Match(PostgreSQLParserSCHEMA)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6480)
			p.Name()
		}

	case 4:
		p.EnterOuterAlt(localctx, 4)
		{
			p.SetState(6482)
			p.Match(PostgreSQLParserALTER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6483)
			p.Match(PostgreSQLParserDOMAIN_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6484)
			p.Any_name()
		}
		{
			p.SetState(6485)
			p.Match(PostgreSQLParserSET)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6486)
			p.Match(PostgreSQLParserSCHEMA)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6487)
			p.Name()
		}

	case 5:
		p.EnterOuterAlt(localctx, 5)
		{
			p.SetState(6489)
			p.Match(PostgreSQLParserALTER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6490)
			p.Match(PostgreSQLParserEXTENSION)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6491)
			p.Name()
		}
		{
			p.SetState(6492)
			p.Match(PostgreSQLParserSET)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6493)
			p.Match(PostgreSQLParserSCHEMA)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6494)
			p.Name()
		}

	case 6:
		p.EnterOuterAlt(localctx, 6)
		{
			p.SetState(6496)
			p.Match(PostgreSQLParserALTER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6497)
			p.Match(PostgreSQLParserFUNCTION)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6498)
			p.Function_with_argtypes()
		}
		{
			p.SetState(6499)
			p.Match(PostgreSQLParserSET)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6500)
			p.Match(PostgreSQLParserSCHEMA)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6501)
			p.Name()
		}

	case 7:
		p.EnterOuterAlt(localctx, 7)
		{
			p.SetState(6503)
			p.Match(PostgreSQLParserALTER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6504)
			p.Match(PostgreSQLParserOPERATOR)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6505)
			p.Operator_with_argtypes()
		}
		{
			p.SetState(6506)
			p.Match(PostgreSQLParserSET)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6507)
			p.Match(PostgreSQLParserSCHEMA)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6508)
			p.Name()
		}

	case 8:
		p.EnterOuterAlt(localctx, 8)
		{
			p.SetState(6510)
			p.Match(PostgreSQLParserALTER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6511)
			p.Match(PostgreSQLParserOPERATOR)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6512)
			p.Match(PostgreSQLParserCLASS)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6513)
			p.Any_name()
		}
		{
			p.SetState(6514)
			p.Match(PostgreSQLParserUSING)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6515)
			p.Name()
		}
		{
			p.SetState(6516)
			p.Match(PostgreSQLParserSET)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6517)
			p.Match(PostgreSQLParserSCHEMA)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6518)
			p.Name()
		}

	case 9:
		p.EnterOuterAlt(localctx, 9)
		{
			p.SetState(6520)
			p.Match(PostgreSQLParserALTER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6521)
			p.Match(PostgreSQLParserOPERATOR)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6522)
			p.Match(PostgreSQLParserFAMILY)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6523)
			p.Any_name()
		}
		{
			p.SetState(6524)
			p.Match(PostgreSQLParserUSING)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6525)
			p.Name()
		}
		{
			p.SetState(6526)
			p.Match(PostgreSQLParserSET)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6527)
			p.Match(PostgreSQLParserSCHEMA)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6528)
			p.Name()
		}

	case 10:
		p.EnterOuterAlt(localctx, 10)
		{
			p.SetState(6530)
			p.Match(PostgreSQLParserALTER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6531)
			p.Match(PostgreSQLParserPROCEDURE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6532)
			p.Function_with_argtypes()
		}
		{
			p.SetState(6533)
			p.Match(PostgreSQLParserSET)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6534)
			p.Match(PostgreSQLParserSCHEMA)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6535)
			p.Name()
		}

	case 11:
		p.EnterOuterAlt(localctx, 11)
		{
			p.SetState(6537)
			p.Match(PostgreSQLParserALTER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6538)
			p.Match(PostgreSQLParserROUTINE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6539)
			p.Function_with_argtypes()
		}
		{
			p.SetState(6540)
			p.Match(PostgreSQLParserSET)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6541)
			p.Match(PostgreSQLParserSCHEMA)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6542)
			p.Name()
		}

	case 12:
		p.EnterOuterAlt(localctx, 12)
		{
			p.SetState(6544)
			p.Match(PostgreSQLParserALTER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6545)
			p.Match(PostgreSQLParserTABLE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6546)
			p.Relation_expr()
		}
		{
			p.SetState(6547)
			p.Match(PostgreSQLParserSET)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6548)
			p.Match(PostgreSQLParserSCHEMA)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6549)
			p.Name()
		}

	case 13:
		p.EnterOuterAlt(localctx, 13)
		{
			p.SetState(6551)
			p.Match(PostgreSQLParserALTER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6552)
			p.Match(PostgreSQLParserTABLE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6553)
			p.Match(PostgreSQLParserIF_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6554)
			p.Match(PostgreSQLParserEXISTS)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6555)
			p.Relation_expr()
		}
		{
			p.SetState(6556)
			p.Match(PostgreSQLParserSET)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6557)
			p.Match(PostgreSQLParserSCHEMA)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6558)
			p.Name()
		}

	case 14:
		p.EnterOuterAlt(localctx, 14)
		{
			p.SetState(6560)
			p.Match(PostgreSQLParserALTER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6561)
			p.Match(PostgreSQLParserSTATISTICS)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6562)
			p.Any_name()
		}
		{
			p.SetState(6563)
			p.Match(PostgreSQLParserSET)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6564)
			p.Match(PostgreSQLParserSCHEMA)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6565)
			p.Name()
		}

	case 15:
		p.EnterOuterAlt(localctx, 15)
		{
			p.SetState(6567)
			p.Match(PostgreSQLParserALTER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6568)
			p.Match(PostgreSQLParserTEXT_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6569)
			p.Match(PostgreSQLParserSEARCH)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6570)
			p.Match(PostgreSQLParserPARSER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6571)
			p.Any_name()
		}
		{
			p.SetState(6572)
			p.Match(PostgreSQLParserSET)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6573)
			p.Match(PostgreSQLParserSCHEMA)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6574)
			p.Name()
		}

	case 16:
		p.EnterOuterAlt(localctx, 16)
		{
			p.SetState(6576)
			p.Match(PostgreSQLParserALTER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6577)
			p.Match(PostgreSQLParserTEXT_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6578)
			p.Match(PostgreSQLParserSEARCH)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6579)
			p.Match(PostgreSQLParserDICTIONARY)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6580)
			p.Any_name()
		}
		{
			p.SetState(6581)
			p.Match(PostgreSQLParserSET)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6582)
			p.Match(PostgreSQLParserSCHEMA)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6583)
			p.Name()
		}

	case 17:
		p.EnterOuterAlt(localctx, 17)
		{
			p.SetState(6585)
			p.Match(PostgreSQLParserALTER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6586)
			p.Match(PostgreSQLParserTEXT_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6587)
			p.Match(PostgreSQLParserSEARCH)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6588)
			p.Match(PostgreSQLParserTEMPLATE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6589)
			p.Any_name()
		}
		{
			p.SetState(6590)
			p.Match(PostgreSQLParserSET)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6591)
			p.Match(PostgreSQLParserSCHEMA)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6592)
			p.Name()
		}

	case 18:
		p.EnterOuterAlt(localctx, 18)
		{
			p.SetState(6594)
			p.Match(PostgreSQLParserALTER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6595)
			p.Match(PostgreSQLParserTEXT_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6596)
			p.Match(PostgreSQLParserSEARCH)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6597)
			p.Match(PostgreSQLParserCONFIGURATION)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6598)
			p.Any_name()
		}
		{
			p.SetState(6599)
			p.Match(PostgreSQLParserSET)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6600)
			p.Match(PostgreSQLParserSCHEMA)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6601)
			p.Name()
		}

	case 19:
		p.EnterOuterAlt(localctx, 19)
		{
			p.SetState(6603)
			p.Match(PostgreSQLParserALTER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6604)
			p.Match(PostgreSQLParserSEQUENCE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6605)
			p.Qualified_name()
		}
		{
			p.SetState(6606)
			p.Match(PostgreSQLParserSET)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6607)
			p.Match(PostgreSQLParserSCHEMA)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6608)
			p.Name()
		}

	case 20:
		p.EnterOuterAlt(localctx, 20)
		{
			p.SetState(6610)
			p.Match(PostgreSQLParserALTER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6611)
			p.Match(PostgreSQLParserSEQUENCE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6612)
			p.Match(PostgreSQLParserIF_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6613)
			p.Match(PostgreSQLParserEXISTS)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6614)
			p.Qualified_name()
		}
		{
			p.SetState(6615)
			p.Match(PostgreSQLParserSET)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6616)
			p.Match(PostgreSQLParserSCHEMA)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6617)
			p.Name()
		}

	case 21:
		p.EnterOuterAlt(localctx, 21)
		{
			p.SetState(6619)
			p.Match(PostgreSQLParserALTER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6620)
			p.Match(PostgreSQLParserVIEW)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6621)
			p.Qualified_name()
		}
		{
			p.SetState(6622)
			p.Match(PostgreSQLParserSET)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6623)
			p.Match(PostgreSQLParserSCHEMA)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6624)
			p.Name()
		}

	case 22:
		p.EnterOuterAlt(localctx, 22)
		{
			p.SetState(6626)
			p.Match(PostgreSQLParserALTER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6627)
			p.Match(PostgreSQLParserVIEW)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6628)
			p.Match(PostgreSQLParserIF_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6629)
			p.Match(PostgreSQLParserEXISTS)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6630)
			p.Qualified_name()
		}
		{
			p.SetState(6631)
			p.Match(PostgreSQLParserSET)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6632)
			p.Match(PostgreSQLParserSCHEMA)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6633)
			p.Name()
		}

	case 23:
		p.EnterOuterAlt(localctx, 23)
		{
			p.SetState(6635)
			p.Match(PostgreSQLParserALTER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6636)
			p.Match(PostgreSQLParserMATERIALIZED)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6637)
			p.Match(PostgreSQLParserVIEW)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6638)
			p.Qualified_name()
		}
		{
			p.SetState(6639)
			p.Match(PostgreSQLParserSET)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6640)
			p.Match(PostgreSQLParserSCHEMA)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6641)
			p.Name()
		}

	case 24:
		p.EnterOuterAlt(localctx, 24)
		{
			p.SetState(6643)
			p.Match(PostgreSQLParserALTER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6644)
			p.Match(PostgreSQLParserMATERIALIZED)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6645)
			p.Match(PostgreSQLParserVIEW)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6646)
			p.Match(PostgreSQLParserIF_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6647)
			p.Match(PostgreSQLParserEXISTS)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6648)
			p.Qualified_name()
		}
		{
			p.SetState(6649)
			p.Match(PostgreSQLParserSET)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6650)
			p.Match(PostgreSQLParserSCHEMA)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6651)
			p.Name()
		}

	case 25:
		p.EnterOuterAlt(localctx, 25)
		{
			p.SetState(6653)
			p.Match(PostgreSQLParserALTER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6654)
			p.Match(PostgreSQLParserFOREIGN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6655)
			p.Match(PostgreSQLParserTABLE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6656)
			p.Relation_expr()
		}
		{
			p.SetState(6657)
			p.Match(PostgreSQLParserSET)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6658)
			p.Match(PostgreSQLParserSCHEMA)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6659)
			p.Name()
		}

	case 26:
		p.EnterOuterAlt(localctx, 26)
		{
			p.SetState(6661)
			p.Match(PostgreSQLParserALTER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6662)
			p.Match(PostgreSQLParserFOREIGN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6663)
			p.Match(PostgreSQLParserTABLE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6664)
			p.Match(PostgreSQLParserIF_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6665)
			p.Match(PostgreSQLParserEXISTS)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6666)
			p.Relation_expr()
		}
		{
			p.SetState(6667)
			p.Match(PostgreSQLParserSET)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6668)
			p.Match(PostgreSQLParserSCHEMA)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6669)
			p.Name()
		}

	case 27:
		p.EnterOuterAlt(localctx, 27)
		{
			p.SetState(6671)
			p.Match(PostgreSQLParserALTER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6672)
			p.Match(PostgreSQLParserTYPE_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6673)
			p.Any_name()
		}
		{
			p.SetState(6674)
			p.Match(PostgreSQLParserSET)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6675)
			p.Match(PostgreSQLParserSCHEMA)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6676)
			p.Name()
		}

	case antlr.ATNInvalidAltNumber:
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IAlteroperatorstmtContext is an interface to support dynamic dispatch.
type IAlteroperatorstmtContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	ALTER() antlr.TerminalNode
	OPERATOR() antlr.TerminalNode
	Operator_with_argtypes() IOperator_with_argtypesContext
	SET() antlr.TerminalNode
	OPEN_PAREN() antlr.TerminalNode
	Operator_def_list() IOperator_def_listContext
	CLOSE_PAREN() antlr.TerminalNode

	// IsAlteroperatorstmtContext differentiates from other interfaces.
	IsAlteroperatorstmtContext()
}

type AlteroperatorstmtContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyAlteroperatorstmtContext() *AlteroperatorstmtContext {
	var p = new(AlteroperatorstmtContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_alteroperatorstmt
	return p
}

func InitEmptyAlteroperatorstmtContext(p *AlteroperatorstmtContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_alteroperatorstmt
}

func (*AlteroperatorstmtContext) IsAlteroperatorstmtContext() {}

func NewAlteroperatorstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AlteroperatorstmtContext {
	var p = new(AlteroperatorstmtContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_alteroperatorstmt

	return p
}

func (s *AlteroperatorstmtContext) GetParser() antlr.Parser { return s.parser }

func (s *AlteroperatorstmtContext) ALTER() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserALTER, 0)
}

func (s *AlteroperatorstmtContext) OPERATOR() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserOPERATOR, 0)
}

func (s *AlteroperatorstmtContext) Operator_with_argtypes() IOperator_with_argtypesContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOperator_with_argtypesContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOperator_with_argtypesContext)
}

func (s *AlteroperatorstmtContext) SET() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserSET, 0)
}

func (s *AlteroperatorstmtContext) OPEN_PAREN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserOPEN_PAREN, 0)
}

func (s *AlteroperatorstmtContext) Operator_def_list() IOperator_def_listContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOperator_def_listContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOperator_def_listContext)
}

func (s *AlteroperatorstmtContext) CLOSE_PAREN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCLOSE_PAREN, 0)
}

func (s *AlteroperatorstmtContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *AlteroperatorstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *AlteroperatorstmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterAlteroperatorstmt(s)
	}
}

func (s *AlteroperatorstmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitAlteroperatorstmt(s)
	}
}

func (s *AlteroperatorstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitAlteroperatorstmt(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Alteroperatorstmt() (localctx IAlteroperatorstmtContext) {
	localctx = NewAlteroperatorstmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 734, PostgreSQLParserRULE_alteroperatorstmt)
	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(6680)
		p.Match(PostgreSQLParserALTER)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(6681)
		p.Match(PostgreSQLParserOPERATOR)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(6682)
		p.Operator_with_argtypes()
	}
	{
		p.SetState(6683)
		p.Match(PostgreSQLParserSET)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(6684)
		p.Match(PostgreSQLParserOPEN_PAREN)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(6685)
		p.Operator_def_list()
	}
	{
		p.SetState(6686)
		p.Match(PostgreSQLParserCLOSE_PAREN)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IOperator_def_listContext is an interface to support dynamic dispatch.
type IOperator_def_listContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	AllOperator_def_elem() []IOperator_def_elemContext
	Operator_def_elem(i int) IOperator_def_elemContext
	AllCOMMA() []antlr.TerminalNode
	COMMA(i int) antlr.TerminalNode

	// IsOperator_def_listContext differentiates from other interfaces.
	IsOperator_def_listContext()
}

type Operator_def_listContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyOperator_def_listContext() *Operator_def_listContext {
	var p = new(Operator_def_listContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_operator_def_list
	return p
}

func InitEmptyOperator_def_listContext(p *Operator_def_listContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_operator_def_list
}

func (*Operator_def_listContext) IsOperator_def_listContext() {}

func NewOperator_def_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Operator_def_listContext {
	var p = new(Operator_def_listContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_operator_def_list

	return p
}

func (s *Operator_def_listContext) GetParser() antlr.Parser { return s.parser }

func (s *Operator_def_listContext) AllOperator_def_elem() []IOperator_def_elemContext {
	children := s.GetChildren()
	len := 0
	for _, ctx := range children {
		if _, ok := ctx.(IOperator_def_elemContext); ok {
			len++
		}
	}

	tst := make([]IOperator_def_elemContext, len)
	i := 0
	for _, ctx := range children {
		if t, ok := ctx.(IOperator_def_elemContext); ok {
			tst[i] = t.(IOperator_def_elemContext)
			i++
		}
	}

	return tst
}

func (s *Operator_def_listContext) Operator_def_elem(i int) IOperator_def_elemContext {
	var t antlr.RuleContext
	j := 0
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOperator_def_elemContext); ok {
			if j == i {
				t = ctx.(antlr.RuleContext)
				break
			}
			j++
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOperator_def_elemContext)
}

func (s *Operator_def_listContext) AllCOMMA() []antlr.TerminalNode {
	return s.GetTokens(PostgreSQLParserCOMMA)
}

func (s *Operator_def_listContext) COMMA(i int) antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCOMMA, i)
}

func (s *Operator_def_listContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Operator_def_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Operator_def_listContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterOperator_def_list(s)
	}
}

func (s *Operator_def_listContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitOperator_def_list(s)
	}
}

func (s *Operator_def_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitOperator_def_list(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Operator_def_list() (localctx IOperator_def_listContext) {
	localctx = NewOperator_def_listContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 736, PostgreSQLParserRULE_operator_def_list)
	var _la int

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(6688)
		p.Operator_def_elem()
	}
	p.SetState(6693)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}
	_la = p.GetTokenStream().LA(1)

	for _la == PostgreSQLParserCOMMA {
		{
			p.SetState(6689)
			p.Match(PostgreSQLParserCOMMA)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6690)
			p.Operator_def_elem()
		}

		p.SetState(6695)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}
		_la = p.GetTokenStream().LA(1)
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IOperator_def_elemContext is an interface to support dynamic dispatch.
type IOperator_def_elemContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Collabel() ICollabelContext
	EQUAL() antlr.TerminalNode
	NONE() antlr.TerminalNode
	Operator_def_arg() IOperator_def_argContext

	// IsOperator_def_elemContext differentiates from other interfaces.
	IsOperator_def_elemContext()
}

type Operator_def_elemContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyOperator_def_elemContext() *Operator_def_elemContext {
	var p = new(Operator_def_elemContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_operator_def_elem
	return p
}

func InitEmptyOperator_def_elemContext(p *Operator_def_elemContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_operator_def_elem
}

func (*Operator_def_elemContext) IsOperator_def_elemContext() {}

func NewOperator_def_elemContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Operator_def_elemContext {
	var p = new(Operator_def_elemContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_operator_def_elem

	return p
}

func (s *Operator_def_elemContext) GetParser() antlr.Parser { return s.parser }

func (s *Operator_def_elemContext) Collabel() ICollabelContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ICollabelContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ICollabelContext)
}

func (s *Operator_def_elemContext) EQUAL() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserEQUAL, 0)
}

func (s *Operator_def_elemContext) NONE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserNONE, 0)
}

func (s *Operator_def_elemContext) Operator_def_arg() IOperator_def_argContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOperator_def_argContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOperator_def_argContext)
}

func (s *Operator_def_elemContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Operator_def_elemContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Operator_def_elemContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterOperator_def_elem(s)
	}
}

func (s *Operator_def_elemContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitOperator_def_elem(s)
	}
}

func (s *Operator_def_elemContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitOperator_def_elem(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Operator_def_elem() (localctx IOperator_def_elemContext) {
	localctx = NewOperator_def_elemContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 738, PostgreSQLParserRULE_operator_def_elem)
	p.SetState(6704)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 317, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(6696)
			p.Collabel()
		}
		{
			p.SetState(6697)
			p.Match(PostgreSQLParserEQUAL)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6698)
			p.Match(PostgreSQLParserNONE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(6700)
			p.Collabel()
		}
		{
			p.SetState(6701)
			p.Match(PostgreSQLParserEQUAL)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6702)
			p.Operator_def_arg()
		}

	case antlr.ATNInvalidAltNumber:
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IOperator_def_argContext is an interface to support dynamic dispatch.
type IOperator_def_argContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Func_type() IFunc_typeContext
	Reserved_keyword() IReserved_keywordContext
	Qual_all_op() IQual_all_opContext
	Numericonly() INumericonlyContext
	Sconst() ISconstContext

	// IsOperator_def_argContext differentiates from other interfaces.
	IsOperator_def_argContext()
}

type Operator_def_argContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyOperator_def_argContext() *Operator_def_argContext {
	var p = new(Operator_def_argContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_operator_def_arg
	return p
}

func InitEmptyOperator_def_argContext(p *Operator_def_argContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_operator_def_arg
}

func (*Operator_def_argContext) IsOperator_def_argContext() {}

func NewOperator_def_argContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Operator_def_argContext {
	var p = new(Operator_def_argContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_operator_def_arg

	return p
}

func (s *Operator_def_argContext) GetParser() antlr.Parser { return s.parser }

func (s *Operator_def_argContext) Func_type() IFunc_typeContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IFunc_typeContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IFunc_typeContext)
}

func (s *Operator_def_argContext) Reserved_keyword() IReserved_keywordContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IReserved_keywordContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IReserved_keywordContext)
}

func (s *Operator_def_argContext) Qual_all_op() IQual_all_opContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IQual_all_opContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IQual_all_opContext)
}

func (s *Operator_def_argContext) Numericonly() INumericonlyContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(INumericonlyContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(INumericonlyContext)
}

func (s *Operator_def_argContext) Sconst() ISconstContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ISconstContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ISconstContext)
}

func (s *Operator_def_argContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Operator_def_argContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Operator_def_argContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterOperator_def_arg(s)
	}
}

func (s *Operator_def_argContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitOperator_def_arg(s)
	}
}

func (s *Operator_def_argContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitOperator_def_arg(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Operator_def_arg() (localctx IOperator_def_argContext) {
	localctx = NewOperator_def_argContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 740, PostgreSQLParserRULE_operator_def_arg)
	p.SetState(6711)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 318, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(6706)
			p.Func_type()
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(6707)
			p.Reserved_keyword()
		}

	case 3:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(6708)
			p.Qual_all_op()
		}

	case 4:
		p.EnterOuterAlt(localctx, 4)
		{
			p.SetState(6709)
			p.Numericonly()
		}

	case 5:
		p.EnterOuterAlt(localctx, 5)
		{
			p.SetState(6710)
			p.Sconst()
		}

	case antlr.ATNInvalidAltNumber:
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IAltertypestmtContext is an interface to support dynamic dispatch.
type IAltertypestmtContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	ALTER() antlr.TerminalNode
	TYPE_P() antlr.TerminalNode
	Any_name() IAny_nameContext
	SET() antlr.TerminalNode
	OPEN_PAREN() antlr.TerminalNode
	Operator_def_list() IOperator_def_listContext
	CLOSE_PAREN() antlr.TerminalNode

	// IsAltertypestmtContext differentiates from other interfaces.
	IsAltertypestmtContext()
}

type AltertypestmtContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyAltertypestmtContext() *AltertypestmtContext {
	var p = new(AltertypestmtContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_altertypestmt
	return p
}

func InitEmptyAltertypestmtContext(p *AltertypestmtContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_altertypestmt
}

func (*AltertypestmtContext) IsAltertypestmtContext() {}

func NewAltertypestmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AltertypestmtContext {
	var p = new(AltertypestmtContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_altertypestmt

	return p
}

func (s *AltertypestmtContext) GetParser() antlr.Parser { return s.parser }

func (s *AltertypestmtContext) ALTER() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserALTER, 0)
}

func (s *AltertypestmtContext) TYPE_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserTYPE_P, 0)
}

func (s *AltertypestmtContext) Any_name() IAny_nameContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IAny_nameContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IAny_nameContext)
}

func (s *AltertypestmtContext) SET() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserSET, 0)
}

func (s *AltertypestmtContext) OPEN_PAREN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserOPEN_PAREN, 0)
}

func (s *AltertypestmtContext) Operator_def_list() IOperator_def_listContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOperator_def_listContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOperator_def_listContext)
}

func (s *AltertypestmtContext) CLOSE_PAREN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCLOSE_PAREN, 0)
}

func (s *AltertypestmtContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *AltertypestmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *AltertypestmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterAltertypestmt(s)
	}
}

func (s *AltertypestmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitAltertypestmt(s)
	}
}

func (s *AltertypestmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitAltertypestmt(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Altertypestmt() (localctx IAltertypestmtContext) {
	localctx = NewAltertypestmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 742, PostgreSQLParserRULE_altertypestmt)
	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(6713)
		p.Match(PostgreSQLParserALTER)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(6714)
		p.Match(PostgreSQLParserTYPE_P)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(6715)
		p.Any_name()
	}
	{
		p.SetState(6716)
		p.Match(PostgreSQLParserSET)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(6717)
		p.Match(PostgreSQLParserOPEN_PAREN)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(6718)
		p.Operator_def_list()
	}
	{
		p.SetState(6719)
		p.Match(PostgreSQLParserCLOSE_PAREN)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IAlterownerstmtContext is an interface to support dynamic dispatch.
type IAlterownerstmtContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	ALTER() antlr.TerminalNode
	AGGREGATE() antlr.TerminalNode
	Aggregate_with_argtypes() IAggregate_with_argtypesContext
	OWNER() antlr.TerminalNode
	TO() antlr.TerminalNode
	Rolespec() IRolespecContext
	COLLATION() antlr.TerminalNode
	Any_name() IAny_nameContext
	CONVERSION_P() antlr.TerminalNode
	DATABASE() antlr.TerminalNode
	Name() INameContext
	DOMAIN_P() antlr.TerminalNode
	FUNCTION() antlr.TerminalNode
	Function_with_argtypes() IFunction_with_argtypesContext
	Opt_procedural() IOpt_proceduralContext
	LANGUAGE() antlr.TerminalNode
	LARGE_P() antlr.TerminalNode
	OBJECT_P() antlr.TerminalNode
	Numericonly() INumericonlyContext
	OPERATOR() antlr.TerminalNode
	Operator_with_argtypes() IOperator_with_argtypesContext
	CLASS() antlr.TerminalNode
	USING() antlr.TerminalNode
	FAMILY() antlr.TerminalNode
	PROCEDURE() antlr.TerminalNode
	ROUTINE() antlr.TerminalNode
	SCHEMA() antlr.TerminalNode
	TYPE_P() antlr.TerminalNode
	TABLESPACE() antlr.TerminalNode
	STATISTICS() antlr.TerminalNode
	TEXT_P() antlr.TerminalNode
	SEARCH() antlr.TerminalNode
	DICTIONARY() antlr.TerminalNode
	CONFIGURATION() antlr.TerminalNode
	FOREIGN() antlr.TerminalNode
	DATA_P() antlr.TerminalNode
	WRAPPER() antlr.TerminalNode
	SERVER() antlr.TerminalNode
	EVENT() antlr.TerminalNode
	TRIGGER() antlr.TerminalNode
	PUBLICATION() antlr.TerminalNode
	SUBSCRIPTION() antlr.TerminalNode

	// IsAlterownerstmtContext differentiates from other interfaces.
	IsAlterownerstmtContext()
}

type AlterownerstmtContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyAlterownerstmtContext() *AlterownerstmtContext {
	var p = new(AlterownerstmtContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_alterownerstmt
	return p
}

func InitEmptyAlterownerstmtContext(p *AlterownerstmtContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_alterownerstmt
}

func (*AlterownerstmtContext) IsAlterownerstmtContext() {}

func NewAlterownerstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AlterownerstmtContext {
	var p = new(AlterownerstmtContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_alterownerstmt

	return p
}

func (s *AlterownerstmtContext) GetParser() antlr.Parser { return s.parser }

func (s *AlterownerstmtContext) ALTER() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserALTER, 0)
}

func (s *AlterownerstmtContext) AGGREGATE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserAGGREGATE, 0)
}

func (s *AlterownerstmtContext) Aggregate_with_argtypes() IAggregate_with_argtypesContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IAggregate_with_argtypesContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IAggregate_with_argtypesContext)
}

func (s *AlterownerstmtContext) OWNER() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserOWNER, 0)
}

func (s *AlterownerstmtContext) TO() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserTO, 0)
}

func (s *AlterownerstmtContext) Rolespec() IRolespecContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IRolespecContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IRolespecContext)
}

func (s *AlterownerstmtContext) COLLATION() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCOLLATION, 0)
}

func (s *AlterownerstmtContext) Any_name() IAny_nameContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IAny_nameContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IAny_nameContext)
}

func (s *AlterownerstmtContext) CONVERSION_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCONVERSION_P, 0)
}

func (s *AlterownerstmtContext) DATABASE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserDATABASE, 0)
}

func (s *AlterownerstmtContext) Name() INameContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(INameContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(INameContext)
}

func (s *AlterownerstmtContext) DOMAIN_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserDOMAIN_P, 0)
}

func (s *AlterownerstmtContext) FUNCTION() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserFUNCTION, 0)
}

func (s *AlterownerstmtContext) Function_with_argtypes() IFunction_with_argtypesContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IFunction_with_argtypesContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IFunction_with_argtypesContext)
}

func (s *AlterownerstmtContext) Opt_procedural() IOpt_proceduralContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOpt_proceduralContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOpt_proceduralContext)
}

func (s *AlterownerstmtContext) LANGUAGE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserLANGUAGE, 0)
}

func (s *AlterownerstmtContext) LARGE_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserLARGE_P, 0)
}

func (s *AlterownerstmtContext) OBJECT_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserOBJECT_P, 0)
}

func (s *AlterownerstmtContext) Numericonly() INumericonlyContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(INumericonlyContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(INumericonlyContext)
}

func (s *AlterownerstmtContext) OPERATOR() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserOPERATOR, 0)
}

func (s *AlterownerstmtContext) Operator_with_argtypes() IOperator_with_argtypesContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOperator_with_argtypesContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOperator_with_argtypesContext)
}

func (s *AlterownerstmtContext) CLASS() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCLASS, 0)
}

func (s *AlterownerstmtContext) USING() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserUSING, 0)
}

func (s *AlterownerstmtContext) FAMILY() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserFAMILY, 0)
}

func (s *AlterownerstmtContext) PROCEDURE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserPROCEDURE, 0)
}

func (s *AlterownerstmtContext) ROUTINE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserROUTINE, 0)
}

func (s *AlterownerstmtContext) SCHEMA() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserSCHEMA, 0)
}

func (s *AlterownerstmtContext) TYPE_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserTYPE_P, 0)
}

func (s *AlterownerstmtContext) TABLESPACE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserTABLESPACE, 0)
}

func (s *AlterownerstmtContext) STATISTICS() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserSTATISTICS, 0)
}

func (s *AlterownerstmtContext) TEXT_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserTEXT_P, 0)
}

func (s *AlterownerstmtContext) SEARCH() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserSEARCH, 0)
}

func (s *AlterownerstmtContext) DICTIONARY() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserDICTIONARY, 0)
}

func (s *AlterownerstmtContext) CONFIGURATION() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCONFIGURATION, 0)
}

func (s *AlterownerstmtContext) FOREIGN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserFOREIGN, 0)
}

func (s *AlterownerstmtContext) DATA_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserDATA_P, 0)
}

func (s *AlterownerstmtContext) WRAPPER() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserWRAPPER, 0)
}

func (s *AlterownerstmtContext) SERVER() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserSERVER, 0)
}

func (s *AlterownerstmtContext) EVENT() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserEVENT, 0)
}

func (s *AlterownerstmtContext) TRIGGER() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserTRIGGER, 0)
}

func (s *AlterownerstmtContext) PUBLICATION() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserPUBLICATION, 0)
}

func (s *AlterownerstmtContext) SUBSCRIPTION() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserSUBSCRIPTION, 0)
}

func (s *AlterownerstmtContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *AlterownerstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *AlterownerstmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterAlterownerstmt(s)
	}
}

func (s *AlterownerstmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitAlterownerstmt(s)
	}
}

func (s *AlterownerstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitAlterownerstmt(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Alterownerstmt() (localctx IAlterownerstmtContext) {
	localctx = NewAlterownerstmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 744, PostgreSQLParserRULE_alterownerstmt)
	p.SetState(6904)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 319, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(6721)
			p.Match(PostgreSQLParserALTER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6722)
			p.Match(PostgreSQLParserAGGREGATE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6723)
			p.Aggregate_with_argtypes()
		}
		{
			p.SetState(6724)
			p.Match(PostgreSQLParserOWNER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6725)
			p.Match(PostgreSQLParserTO)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6726)
			p.Rolespec()
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(6728)
			p.Match(PostgreSQLParserALTER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6729)
			p.Match(PostgreSQLParserCOLLATION)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6730)
			p.Any_name()
		}
		{
			p.SetState(6731)
			p.Match(PostgreSQLParserOWNER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6732)
			p.Match(PostgreSQLParserTO)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6733)
			p.Rolespec()
		}

	case 3:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(6735)
			p.Match(PostgreSQLParserALTER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6736)
			p.Match(PostgreSQLParserCONVERSION_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6737)
			p.Any_name()
		}
		{
			p.SetState(6738)
			p.Match(PostgreSQLParserOWNER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6739)
			p.Match(PostgreSQLParserTO)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6740)
			p.Rolespec()
		}

	case 4:
		p.EnterOuterAlt(localctx, 4)
		{
			p.SetState(6742)
			p.Match(PostgreSQLParserALTER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6743)
			p.Match(PostgreSQLParserDATABASE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6744)
			p.Name()
		}
		{
			p.SetState(6745)
			p.Match(PostgreSQLParserOWNER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6746)
			p.Match(PostgreSQLParserTO)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6747)
			p.Rolespec()
		}

	case 5:
		p.EnterOuterAlt(localctx, 5)
		{
			p.SetState(6749)
			p.Match(PostgreSQLParserALTER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6750)
			p.Match(PostgreSQLParserDOMAIN_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6751)
			p.Any_name()
		}
		{
			p.SetState(6752)
			p.Match(PostgreSQLParserOWNER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6753)
			p.Match(PostgreSQLParserTO)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6754)
			p.Rolespec()
		}

	case 6:
		p.EnterOuterAlt(localctx, 6)
		{
			p.SetState(6756)
			p.Match(PostgreSQLParserALTER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6757)
			p.Match(PostgreSQLParserFUNCTION)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6758)
			p.Function_with_argtypes()
		}
		{
			p.SetState(6759)
			p.Match(PostgreSQLParserOWNER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6760)
			p.Match(PostgreSQLParserTO)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6761)
			p.Rolespec()
		}

	case 7:
		p.EnterOuterAlt(localctx, 7)
		{
			p.SetState(6763)
			p.Match(PostgreSQLParserALTER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6764)
			p.Opt_procedural()
		}
		{
			p.SetState(6765)
			p.Match(PostgreSQLParserLANGUAGE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6766)
			p.Name()
		}
		{
			p.SetState(6767)
			p.Match(PostgreSQLParserOWNER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6768)
			p.Match(PostgreSQLParserTO)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6769)
			p.Rolespec()
		}

	case 8:
		p.EnterOuterAlt(localctx, 8)
		{
			p.SetState(6771)
			p.Match(PostgreSQLParserALTER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6772)
			p.Match(PostgreSQLParserLARGE_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6773)
			p.Match(PostgreSQLParserOBJECT_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6774)
			p.Numericonly()
		}
		{
			p.SetState(6775)
			p.Match(PostgreSQLParserOWNER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6776)
			p.Match(PostgreSQLParserTO)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6777)
			p.Rolespec()
		}

	case 9:
		p.EnterOuterAlt(localctx, 9)
		{
			p.SetState(6779)
			p.Match(PostgreSQLParserALTER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6780)
			p.Match(PostgreSQLParserOPERATOR)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6781)
			p.Operator_with_argtypes()
		}
		{
			p.SetState(6782)
			p.Match(PostgreSQLParserOWNER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6783)
			p.Match(PostgreSQLParserTO)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6784)
			p.Rolespec()
		}

	case 10:
		p.EnterOuterAlt(localctx, 10)
		{
			p.SetState(6786)
			p.Match(PostgreSQLParserALTER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6787)
			p.Match(PostgreSQLParserOPERATOR)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6788)
			p.Match(PostgreSQLParserCLASS)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6789)
			p.Any_name()
		}
		{
			p.SetState(6790)
			p.Match(PostgreSQLParserUSING)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6791)
			p.Name()
		}
		{
			p.SetState(6792)
			p.Match(PostgreSQLParserOWNER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6793)
			p.Match(PostgreSQLParserTO)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6794)
			p.Rolespec()
		}

	case 11:
		p.EnterOuterAlt(localctx, 11)
		{
			p.SetState(6796)
			p.Match(PostgreSQLParserALTER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6797)
			p.Match(PostgreSQLParserOPERATOR)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6798)
			p.Match(PostgreSQLParserFAMILY)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6799)
			p.Any_name()
		}
		{
			p.SetState(6800)
			p.Match(PostgreSQLParserUSING)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6801)
			p.Name()
		}
		{
			p.SetState(6802)
			p.Match(PostgreSQLParserOWNER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6803)
			p.Match(PostgreSQLParserTO)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6804)
			p.Rolespec()
		}

	case 12:
		p.EnterOuterAlt(localctx, 12)
		{
			p.SetState(6806)
			p.Match(PostgreSQLParserALTER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6807)
			p.Match(PostgreSQLParserPROCEDURE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6808)
			p.Function_with_argtypes()
		}
		{
			p.SetState(6809)
			p.Match(PostgreSQLParserOWNER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6810)
			p.Match(PostgreSQLParserTO)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6811)
			p.Rolespec()
		}

	case 13:
		p.EnterOuterAlt(localctx, 13)
		{
			p.SetState(6813)
			p.Match(PostgreSQLParserALTER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6814)
			p.Match(PostgreSQLParserROUTINE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6815)
			p.Function_with_argtypes()
		}
		{
			p.SetState(6816)
			p.Match(PostgreSQLParserOWNER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6817)
			p.Match(PostgreSQLParserTO)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6818)
			p.Rolespec()
		}

	case 14:
		p.EnterOuterAlt(localctx, 14)
		{
			p.SetState(6820)
			p.Match(PostgreSQLParserALTER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6821)
			p.Match(PostgreSQLParserSCHEMA)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6822)
			p.Name()
		}
		{
			p.SetState(6823)
			p.Match(PostgreSQLParserOWNER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6824)
			p.Match(PostgreSQLParserTO)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6825)
			p.Rolespec()
		}

	case 15:
		p.EnterOuterAlt(localctx, 15)
		{
			p.SetState(6827)
			p.Match(PostgreSQLParserALTER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6828)
			p.Match(PostgreSQLParserTYPE_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6829)
			p.Any_name()
		}
		{
			p.SetState(6830)
			p.Match(PostgreSQLParserOWNER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6831)
			p.Match(PostgreSQLParserTO)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6832)
			p.Rolespec()
		}

	case 16:
		p.EnterOuterAlt(localctx, 16)
		{
			p.SetState(6834)
			p.Match(PostgreSQLParserALTER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6835)
			p.Match(PostgreSQLParserTABLESPACE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6836)
			p.Name()
		}
		{
			p.SetState(6837)
			p.Match(PostgreSQLParserOWNER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6838)
			p.Match(PostgreSQLParserTO)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6839)
			p.Rolespec()
		}

	case 17:
		p.EnterOuterAlt(localctx, 17)
		{
			p.SetState(6841)
			p.Match(PostgreSQLParserALTER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6842)
			p.Match(PostgreSQLParserSTATISTICS)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6843)
			p.Any_name()
		}
		{
			p.SetState(6844)
			p.Match(PostgreSQLParserOWNER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6845)
			p.Match(PostgreSQLParserTO)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6846)
			p.Rolespec()
		}

	case 18:
		p.EnterOuterAlt(localctx, 18)
		{
			p.SetState(6848)
			p.Match(PostgreSQLParserALTER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6849)
			p.Match(PostgreSQLParserTEXT_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6850)
			p.Match(PostgreSQLParserSEARCH)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6851)
			p.Match(PostgreSQLParserDICTIONARY)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6852)
			p.Any_name()
		}
		{
			p.SetState(6853)
			p.Match(PostgreSQLParserOWNER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6854)
			p.Match(PostgreSQLParserTO)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6855)
			p.Rolespec()
		}

	case 19:
		p.EnterOuterAlt(localctx, 19)
		{
			p.SetState(6857)
			p.Match(PostgreSQLParserALTER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6858)
			p.Match(PostgreSQLParserTEXT_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6859)
			p.Match(PostgreSQLParserSEARCH)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6860)
			p.Match(PostgreSQLParserCONFIGURATION)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6861)
			p.Any_name()
		}
		{
			p.SetState(6862)
			p.Match(PostgreSQLParserOWNER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6863)
			p.Match(PostgreSQLParserTO)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6864)
			p.Rolespec()
		}

	case 20:
		p.EnterOuterAlt(localctx, 20)
		{
			p.SetState(6866)
			p.Match(PostgreSQLParserALTER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6867)
			p.Match(PostgreSQLParserFOREIGN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6868)
			p.Match(PostgreSQLParserDATA_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6869)
			p.Match(PostgreSQLParserWRAPPER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6870)
			p.Name()
		}
		{
			p.SetState(6871)
			p.Match(PostgreSQLParserOWNER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6872)
			p.Match(PostgreSQLParserTO)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6873)
			p.Rolespec()
		}

	case 21:
		p.EnterOuterAlt(localctx, 21)
		{
			p.SetState(6875)
			p.Match(PostgreSQLParserALTER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6876)
			p.Match(PostgreSQLParserSERVER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6877)
			p.Name()
		}
		{
			p.SetState(6878)
			p.Match(PostgreSQLParserOWNER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6879)
			p.Match(PostgreSQLParserTO)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6880)
			p.Rolespec()
		}

	case 22:
		p.EnterOuterAlt(localctx, 22)
		{
			p.SetState(6882)
			p.Match(PostgreSQLParserALTER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6883)
			p.Match(PostgreSQLParserEVENT)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6884)
			p.Match(PostgreSQLParserTRIGGER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6885)
			p.Name()
		}
		{
			p.SetState(6886)
			p.Match(PostgreSQLParserOWNER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6887)
			p.Match(PostgreSQLParserTO)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6888)
			p.Rolespec()
		}

	case 23:
		p.EnterOuterAlt(localctx, 23)
		{
			p.SetState(6890)
			p.Match(PostgreSQLParserALTER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6891)
			p.Match(PostgreSQLParserPUBLICATION)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6892)
			p.Name()
		}
		{
			p.SetState(6893)
			p.Match(PostgreSQLParserOWNER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6894)
			p.Match(PostgreSQLParserTO)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6895)
			p.Rolespec()
		}

	case 24:
		p.EnterOuterAlt(localctx, 24)
		{
			p.SetState(6897)
			p.Match(PostgreSQLParserALTER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6898)
			p.Match(PostgreSQLParserSUBSCRIPTION)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6899)
			p.Name()
		}
		{
			p.SetState(6900)
			p.Match(PostgreSQLParserOWNER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6901)
			p.Match(PostgreSQLParserTO)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6902)
			p.Rolespec()
		}

	case antlr.ATNInvalidAltNumber:
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// ICreatepublicationstmtContext is an interface to support dynamic dispatch.
type ICreatepublicationstmtContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	CREATE() antlr.TerminalNode
	PUBLICATION() antlr.TerminalNode
	Name() INameContext
	Opt_publication_for_tables() IOpt_publication_for_tablesContext
	Opt_definition() IOpt_definitionContext

	// IsCreatepublicationstmtContext differentiates from other interfaces.
	IsCreatepublicationstmtContext()
}

type CreatepublicationstmtContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyCreatepublicationstmtContext() *CreatepublicationstmtContext {
	var p = new(CreatepublicationstmtContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_createpublicationstmt
	return p
}

func InitEmptyCreatepublicationstmtContext(p *CreatepublicationstmtContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_createpublicationstmt
}

func (*CreatepublicationstmtContext) IsCreatepublicationstmtContext() {}

func NewCreatepublicationstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CreatepublicationstmtContext {
	var p = new(CreatepublicationstmtContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_createpublicationstmt

	return p
}

func (s *CreatepublicationstmtContext) GetParser() antlr.Parser { return s.parser }

func (s *CreatepublicationstmtContext) CREATE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCREATE, 0)
}

func (s *CreatepublicationstmtContext) PUBLICATION() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserPUBLICATION, 0)
}

func (s *CreatepublicationstmtContext) Name() INameContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(INameContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(INameContext)
}

func (s *CreatepublicationstmtContext) Opt_publication_for_tables() IOpt_publication_for_tablesContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOpt_publication_for_tablesContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOpt_publication_for_tablesContext)
}

func (s *CreatepublicationstmtContext) Opt_definition() IOpt_definitionContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOpt_definitionContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOpt_definitionContext)
}

func (s *CreatepublicationstmtContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *CreatepublicationstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *CreatepublicationstmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterCreatepublicationstmt(s)
	}
}

func (s *CreatepublicationstmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitCreatepublicationstmt(s)
	}
}

func (s *CreatepublicationstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitCreatepublicationstmt(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Createpublicationstmt() (localctx ICreatepublicationstmtContext) {
	localctx = NewCreatepublicationstmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 746, PostgreSQLParserRULE_createpublicationstmt)
	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(6906)
		p.Match(PostgreSQLParserCREATE)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(6907)
		p.Match(PostgreSQLParserPUBLICATION)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(6908)
		p.Name()
	}
	{
		p.SetState(6909)
		p.Opt_publication_for_tables()
	}
	{
		p.SetState(6910)
		p.Opt_definition()
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IOpt_publication_for_tablesContext is an interface to support dynamic dispatch.
type IOpt_publication_for_tablesContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Publication_for_tables() IPublication_for_tablesContext

	// IsOpt_publication_for_tablesContext differentiates from other interfaces.
	IsOpt_publication_for_tablesContext()
}

type Opt_publication_for_tablesContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyOpt_publication_for_tablesContext() *Opt_publication_for_tablesContext {
	var p = new(Opt_publication_for_tablesContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opt_publication_for_tables
	return p
}

func InitEmptyOpt_publication_for_tablesContext(p *Opt_publication_for_tablesContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opt_publication_for_tables
}

func (*Opt_publication_for_tablesContext) IsOpt_publication_for_tablesContext() {}

func NewOpt_publication_for_tablesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_publication_for_tablesContext {
	var p = new(Opt_publication_for_tablesContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_opt_publication_for_tables

	return p
}

func (s *Opt_publication_for_tablesContext) GetParser() antlr.Parser { return s.parser }

func (s *Opt_publication_for_tablesContext) Publication_for_tables() IPublication_for_tablesContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IPublication_for_tablesContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IPublication_for_tablesContext)
}

func (s *Opt_publication_for_tablesContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Opt_publication_for_tablesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Opt_publication_for_tablesContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterOpt_publication_for_tables(s)
	}
}

func (s *Opt_publication_for_tablesContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitOpt_publication_for_tables(s)
	}
}

func (s *Opt_publication_for_tablesContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitOpt_publication_for_tables(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Opt_publication_for_tables() (localctx IOpt_publication_for_tablesContext) {
	localctx = NewOpt_publication_for_tablesContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 748, PostgreSQLParserRULE_opt_publication_for_tables)
	p.SetState(6914)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetTokenStream().LA(1) {
	case PostgreSQLParserFOR:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(6912)
			p.Publication_for_tables()
		}

	case PostgreSQLParserEOF, PostgreSQLParserOPEN_PAREN, PostgreSQLParserSEMI, PostgreSQLParserANALYSE, PostgreSQLParserANALYZE, PostgreSQLParserCREATE, PostgreSQLParserDO, PostgreSQLParserFETCH, PostgreSQLParserGRANT, PostgreSQLParserINTO, PostgreSQLParserSELECT, PostgreSQLParserTABLE, PostgreSQLParserWITH, PostgreSQLParserABORT_P, PostgreSQLParserALTER, PostgreSQLParserBEGIN_P, PostgreSQLParserCHECKPOINT, PostgreSQLParserCLOSE, PostgreSQLParserCLUSTER, PostgreSQLParserCOMMENT, PostgreSQLParserCOMMIT, PostgreSQLParserCOPY, PostgreSQLParserDEALLOCATE, PostgreSQLParserDECLARE, PostgreSQLParserDELETE_P, PostgreSQLParserDISCARD, PostgreSQLParserDROP, PostgreSQLParserEXECUTE, PostgreSQLParserEXPLAIN, PostgreSQLParserINSERT, PostgreSQLParserLISTEN, PostgreSQLParserLOAD, PostgreSQLParserLOCK_P, PostgreSQLParserMERGE, PostgreSQLParserMOVE, PostgreSQLParserNOTIFY, PostgreSQLParserPREPARE, PostgreSQLParserREASSIGN, PostgreSQLParserREFRESH, PostgreSQLParserREINDEX, PostgreSQLParserRELEASE, PostgreSQLParserRESET, PostgreSQLParserREVOKE, PostgreSQLParserROLLBACK, PostgreSQLParserSAVEPOINT, PostgreSQLParserSECURITY, PostgreSQLParserSET, PostgreSQLParserSHOW, PostgreSQLParserSTART, PostgreSQLParserTRUNCATE, PostgreSQLParserUNLISTEN, PostgreSQLParserUPDATE, PostgreSQLParserVACUUM, PostgreSQLParserVALUES, PostgreSQLParserCALL, PostgreSQLParserIMPORT_P, PostgreSQLParserEND_P, PostgreSQLParserMetaCommand:
		p.EnterOuterAlt(localctx, 2)

	default:
		p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IPublication_for_tablesContext is an interface to support dynamic dispatch.
type IPublication_for_tablesContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	FOR() antlr.TerminalNode
	TABLE() antlr.TerminalNode
	Relation_expr_list() IRelation_expr_listContext
	ALL() antlr.TerminalNode
	TABLES() antlr.TerminalNode

	// IsPublication_for_tablesContext differentiates from other interfaces.
	IsPublication_for_tablesContext()
}

type Publication_for_tablesContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyPublication_for_tablesContext() *Publication_for_tablesContext {
	var p = new(Publication_for_tablesContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_publication_for_tables
	return p
}

func InitEmptyPublication_for_tablesContext(p *Publication_for_tablesContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_publication_for_tables
}

func (*Publication_for_tablesContext) IsPublication_for_tablesContext() {}

func NewPublication_for_tablesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Publication_for_tablesContext {
	var p = new(Publication_for_tablesContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_publication_for_tables

	return p
}

func (s *Publication_for_tablesContext) GetParser() antlr.Parser { return s.parser }

func (s *Publication_for_tablesContext) FOR() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserFOR, 0)
}

func (s *Publication_for_tablesContext) TABLE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserTABLE, 0)
}

func (s *Publication_for_tablesContext) Relation_expr_list() IRelation_expr_listContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IRelation_expr_listContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IRelation_expr_listContext)
}

func (s *Publication_for_tablesContext) ALL() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserALL, 0)
}

func (s *Publication_for_tablesContext) TABLES() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserTABLES, 0)
}

func (s *Publication_for_tablesContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Publication_for_tablesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Publication_for_tablesContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterPublication_for_tables(s)
	}
}

func (s *Publication_for_tablesContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitPublication_for_tables(s)
	}
}

func (s *Publication_for_tablesContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitPublication_for_tables(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Publication_for_tables() (localctx IPublication_for_tablesContext) {
	localctx = NewPublication_for_tablesContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 750, PostgreSQLParserRULE_publication_for_tables)
	p.SetState(6922)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 321, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(6916)
			p.Match(PostgreSQLParserFOR)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6917)
			p.Match(PostgreSQLParserTABLE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6918)
			p.Relation_expr_list()
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(6919)
			p.Match(PostgreSQLParserFOR)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6920)
			p.Match(PostgreSQLParserALL)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6921)
			p.Match(PostgreSQLParserTABLES)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case antlr.ATNInvalidAltNumber:
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IAlterpublicationstmtContext is an interface to support dynamic dispatch.
type IAlterpublicationstmtContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	ALTER() antlr.TerminalNode
	PUBLICATION() antlr.TerminalNode
	Name() INameContext
	SET() antlr.TerminalNode
	Definition() IDefinitionContext
	ADD_P() antlr.TerminalNode
	TABLE() antlr.TerminalNode
	Relation_expr_list() IRelation_expr_listContext
	DROP() antlr.TerminalNode

	// IsAlterpublicationstmtContext differentiates from other interfaces.
	IsAlterpublicationstmtContext()
}

type AlterpublicationstmtContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyAlterpublicationstmtContext() *AlterpublicationstmtContext {
	var p = new(AlterpublicationstmtContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_alterpublicationstmt
	return p
}

func InitEmptyAlterpublicationstmtContext(p *AlterpublicationstmtContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_alterpublicationstmt
}

func (*AlterpublicationstmtContext) IsAlterpublicationstmtContext() {}

func NewAlterpublicationstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AlterpublicationstmtContext {
	var p = new(AlterpublicationstmtContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_alterpublicationstmt

	return p
}

func (s *AlterpublicationstmtContext) GetParser() antlr.Parser { return s.parser }

func (s *AlterpublicationstmtContext) ALTER() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserALTER, 0)
}

func (s *AlterpublicationstmtContext) PUBLICATION() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserPUBLICATION, 0)
}

func (s *AlterpublicationstmtContext) Name() INameContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(INameContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(INameContext)
}

func (s *AlterpublicationstmtContext) SET() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserSET, 0)
}

func (s *AlterpublicationstmtContext) Definition() IDefinitionContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IDefinitionContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IDefinitionContext)
}

func (s *AlterpublicationstmtContext) ADD_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserADD_P, 0)
}

func (s *AlterpublicationstmtContext) TABLE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserTABLE, 0)
}

func (s *AlterpublicationstmtContext) Relation_expr_list() IRelation_expr_listContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IRelation_expr_listContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IRelation_expr_listContext)
}

func (s *AlterpublicationstmtContext) DROP() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserDROP, 0)
}

func (s *AlterpublicationstmtContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *AlterpublicationstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *AlterpublicationstmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterAlterpublicationstmt(s)
	}
}

func (s *AlterpublicationstmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitAlterpublicationstmt(s)
	}
}

func (s *AlterpublicationstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitAlterpublicationstmt(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Alterpublicationstmt() (localctx IAlterpublicationstmtContext) {
	localctx = NewAlterpublicationstmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 752, PostgreSQLParserRULE_alterpublicationstmt)
	p.SetState(6951)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 322, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(6924)
			p.Match(PostgreSQLParserALTER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6925)
			p.Match(PostgreSQLParserPUBLICATION)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6926)
			p.Name()
		}
		{
			p.SetState(6927)
			p.Match(PostgreSQLParserSET)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6928)
			p.Definition()
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(6930)
			p.Match(PostgreSQLParserALTER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6931)
			p.Match(PostgreSQLParserPUBLICATION)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6932)
			p.Name()
		}
		{
			p.SetState(6933)
			p.Match(PostgreSQLParserADD_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6934)
			p.Match(PostgreSQLParserTABLE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6935)
			p.Relation_expr_list()
		}

	case 3:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(6937)
			p.Match(PostgreSQLParserALTER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6938)
			p.Match(PostgreSQLParserPUBLICATION)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6939)
			p.Name()
		}
		{
			p.SetState(6940)
			p.Match(PostgreSQLParserSET)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6941)
			p.Match(PostgreSQLParserTABLE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6942)
			p.Relation_expr_list()
		}

	case 4:
		p.EnterOuterAlt(localctx, 4)
		{
			p.SetState(6944)
			p.Match(PostgreSQLParserALTER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6945)
			p.Match(PostgreSQLParserPUBLICATION)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6946)
			p.Name()
		}
		{
			p.SetState(6947)
			p.Match(PostgreSQLParserDROP)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6948)
			p.Match(PostgreSQLParserTABLE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6949)
			p.Relation_expr_list()
		}

	case antlr.ATNInvalidAltNumber:
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// ICreatesubscriptionstmtContext is an interface to support dynamic dispatch.
type ICreatesubscriptionstmtContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	CREATE() antlr.TerminalNode
	SUBSCRIPTION() antlr.TerminalNode
	Name() INameContext
	CONNECTION() antlr.TerminalNode
	Sconst() ISconstContext
	PUBLICATION() antlr.TerminalNode
	Publication_name_list() IPublication_name_listContext
	Opt_definition() IOpt_definitionContext

	// IsCreatesubscriptionstmtContext differentiates from other interfaces.
	IsCreatesubscriptionstmtContext()
}

type CreatesubscriptionstmtContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyCreatesubscriptionstmtContext() *CreatesubscriptionstmtContext {
	var p = new(CreatesubscriptionstmtContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_createsubscriptionstmt
	return p
}

func InitEmptyCreatesubscriptionstmtContext(p *CreatesubscriptionstmtContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_createsubscriptionstmt
}

func (*CreatesubscriptionstmtContext) IsCreatesubscriptionstmtContext() {}

func NewCreatesubscriptionstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CreatesubscriptionstmtContext {
	var p = new(CreatesubscriptionstmtContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_createsubscriptionstmt

	return p
}

func (s *CreatesubscriptionstmtContext) GetParser() antlr.Parser { return s.parser }

func (s *CreatesubscriptionstmtContext) CREATE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCREATE, 0)
}

func (s *CreatesubscriptionstmtContext) SUBSCRIPTION() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserSUBSCRIPTION, 0)
}

func (s *CreatesubscriptionstmtContext) Name() INameContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(INameContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(INameContext)
}

func (s *CreatesubscriptionstmtContext) CONNECTION() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCONNECTION, 0)
}

func (s *CreatesubscriptionstmtContext) Sconst() ISconstContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ISconstContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ISconstContext)
}

func (s *CreatesubscriptionstmtContext) PUBLICATION() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserPUBLICATION, 0)
}

func (s *CreatesubscriptionstmtContext) Publication_name_list() IPublication_name_listContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IPublication_name_listContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IPublication_name_listContext)
}

func (s *CreatesubscriptionstmtContext) Opt_definition() IOpt_definitionContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOpt_definitionContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOpt_definitionContext)
}

func (s *CreatesubscriptionstmtContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *CreatesubscriptionstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *CreatesubscriptionstmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterCreatesubscriptionstmt(s)
	}
}

func (s *CreatesubscriptionstmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitCreatesubscriptionstmt(s)
	}
}

func (s *CreatesubscriptionstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitCreatesubscriptionstmt(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Createsubscriptionstmt() (localctx ICreatesubscriptionstmtContext) {
	localctx = NewCreatesubscriptionstmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 754, PostgreSQLParserRULE_createsubscriptionstmt)
	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(6953)
		p.Match(PostgreSQLParserCREATE)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(6954)
		p.Match(PostgreSQLParserSUBSCRIPTION)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(6955)
		p.Name()
	}
	{
		p.SetState(6956)
		p.Match(PostgreSQLParserCONNECTION)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(6957)
		p.Sconst()
	}
	{
		p.SetState(6958)
		p.Match(PostgreSQLParserPUBLICATION)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(6959)
		p.Publication_name_list()
	}
	{
		p.SetState(6960)
		p.Opt_definition()
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IPublication_name_listContext is an interface to support dynamic dispatch.
type IPublication_name_listContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	AllPublication_name_item() []IPublication_name_itemContext
	Publication_name_item(i int) IPublication_name_itemContext
	AllCOMMA() []antlr.TerminalNode
	COMMA(i int) antlr.TerminalNode

	// IsPublication_name_listContext differentiates from other interfaces.
	IsPublication_name_listContext()
}

type Publication_name_listContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyPublication_name_listContext() *Publication_name_listContext {
	var p = new(Publication_name_listContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_publication_name_list
	return p
}

func InitEmptyPublication_name_listContext(p *Publication_name_listContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_publication_name_list
}

func (*Publication_name_listContext) IsPublication_name_listContext() {}

func NewPublication_name_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Publication_name_listContext {
	var p = new(Publication_name_listContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_publication_name_list

	return p
}

func (s *Publication_name_listContext) GetParser() antlr.Parser { return s.parser }

func (s *Publication_name_listContext) AllPublication_name_item() []IPublication_name_itemContext {
	children := s.GetChildren()
	len := 0
	for _, ctx := range children {
		if _, ok := ctx.(IPublication_name_itemContext); ok {
			len++
		}
	}

	tst := make([]IPublication_name_itemContext, len)
	i := 0
	for _, ctx := range children {
		if t, ok := ctx.(IPublication_name_itemContext); ok {
			tst[i] = t.(IPublication_name_itemContext)
			i++
		}
	}

	return tst
}

func (s *Publication_name_listContext) Publication_name_item(i int) IPublication_name_itemContext {
	var t antlr.RuleContext
	j := 0
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IPublication_name_itemContext); ok {
			if j == i {
				t = ctx.(antlr.RuleContext)
				break
			}
			j++
		}
	}

	if t == nil {
		return nil
	}

	return t.(IPublication_name_itemContext)
}

func (s *Publication_name_listContext) AllCOMMA() []antlr.TerminalNode {
	return s.GetTokens(PostgreSQLParserCOMMA)
}

func (s *Publication_name_listContext) COMMA(i int) antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCOMMA, i)
}

func (s *Publication_name_listContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Publication_name_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Publication_name_listContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterPublication_name_list(s)
	}
}

func (s *Publication_name_listContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitPublication_name_list(s)
	}
}

func (s *Publication_name_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitPublication_name_list(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Publication_name_list() (localctx IPublication_name_listContext) {
	localctx = NewPublication_name_listContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 756, PostgreSQLParserRULE_publication_name_list)
	var _la int

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(6962)
		p.Publication_name_item()
	}
	p.SetState(6967)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}
	_la = p.GetTokenStream().LA(1)

	for _la == PostgreSQLParserCOMMA {
		{
			p.SetState(6963)
			p.Match(PostgreSQLParserCOMMA)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6964)
			p.Publication_name_item()
		}

		p.SetState(6969)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}
		_la = p.GetTokenStream().LA(1)
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IPublication_name_itemContext is an interface to support dynamic dispatch.
type IPublication_name_itemContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Collabel() ICollabelContext

	// IsPublication_name_itemContext differentiates from other interfaces.
	IsPublication_name_itemContext()
}

type Publication_name_itemContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyPublication_name_itemContext() *Publication_name_itemContext {
	var p = new(Publication_name_itemContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_publication_name_item
	return p
}

func InitEmptyPublication_name_itemContext(p *Publication_name_itemContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_publication_name_item
}

func (*Publication_name_itemContext) IsPublication_name_itemContext() {}

func NewPublication_name_itemContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Publication_name_itemContext {
	var p = new(Publication_name_itemContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_publication_name_item

	return p
}

func (s *Publication_name_itemContext) GetParser() antlr.Parser { return s.parser }

func (s *Publication_name_itemContext) Collabel() ICollabelContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ICollabelContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ICollabelContext)
}

func (s *Publication_name_itemContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Publication_name_itemContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Publication_name_itemContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterPublication_name_item(s)
	}
}

func (s *Publication_name_itemContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitPublication_name_item(s)
	}
}

func (s *Publication_name_itemContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitPublication_name_item(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Publication_name_item() (localctx IPublication_name_itemContext) {
	localctx = NewPublication_name_itemContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 758, PostgreSQLParserRULE_publication_name_item)
	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(6970)
		p.Collabel()
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IAltersubscriptionstmtContext is an interface to support dynamic dispatch.
type IAltersubscriptionstmtContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	ALTER() antlr.TerminalNode
	SUBSCRIPTION() antlr.TerminalNode
	Name() INameContext
	SET() antlr.TerminalNode
	Definition() IDefinitionContext
	CONNECTION() antlr.TerminalNode
	Sconst() ISconstContext
	REFRESH() antlr.TerminalNode
	PUBLICATION() antlr.TerminalNode
	Opt_definition() IOpt_definitionContext
	Publication_name_list() IPublication_name_listContext
	ENABLE_P() antlr.TerminalNode
	DISABLE_P() antlr.TerminalNode

	// IsAltersubscriptionstmtContext differentiates from other interfaces.
	IsAltersubscriptionstmtContext()
}

type AltersubscriptionstmtContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyAltersubscriptionstmtContext() *AltersubscriptionstmtContext {
	var p = new(AltersubscriptionstmtContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_altersubscriptionstmt
	return p
}

func InitEmptyAltersubscriptionstmtContext(p *AltersubscriptionstmtContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_altersubscriptionstmt
}

func (*AltersubscriptionstmtContext) IsAltersubscriptionstmtContext() {}

func NewAltersubscriptionstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AltersubscriptionstmtContext {
	var p = new(AltersubscriptionstmtContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_altersubscriptionstmt

	return p
}

func (s *AltersubscriptionstmtContext) GetParser() antlr.Parser { return s.parser }

func (s *AltersubscriptionstmtContext) ALTER() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserALTER, 0)
}

func (s *AltersubscriptionstmtContext) SUBSCRIPTION() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserSUBSCRIPTION, 0)
}

func (s *AltersubscriptionstmtContext) Name() INameContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(INameContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(INameContext)
}

func (s *AltersubscriptionstmtContext) SET() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserSET, 0)
}

func (s *AltersubscriptionstmtContext) Definition() IDefinitionContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IDefinitionContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IDefinitionContext)
}

func (s *AltersubscriptionstmtContext) CONNECTION() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCONNECTION, 0)
}

func (s *AltersubscriptionstmtContext) Sconst() ISconstContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ISconstContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ISconstContext)
}

func (s *AltersubscriptionstmtContext) REFRESH() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserREFRESH, 0)
}

func (s *AltersubscriptionstmtContext) PUBLICATION() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserPUBLICATION, 0)
}

func (s *AltersubscriptionstmtContext) Opt_definition() IOpt_definitionContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOpt_definitionContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOpt_definitionContext)
}

func (s *AltersubscriptionstmtContext) Publication_name_list() IPublication_name_listContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IPublication_name_listContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IPublication_name_listContext)
}

func (s *AltersubscriptionstmtContext) ENABLE_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserENABLE_P, 0)
}

func (s *AltersubscriptionstmtContext) DISABLE_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserDISABLE_P, 0)
}

func (s *AltersubscriptionstmtContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *AltersubscriptionstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *AltersubscriptionstmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterAltersubscriptionstmt(s)
	}
}

func (s *AltersubscriptionstmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitAltersubscriptionstmt(s)
	}
}

func (s *AltersubscriptionstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitAltersubscriptionstmt(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Altersubscriptionstmt() (localctx IAltersubscriptionstmtContext) {
	localctx = NewAltersubscriptionstmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 760, PostgreSQLParserRULE_altersubscriptionstmt)
	p.SetState(7009)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 324, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(6972)
			p.Match(PostgreSQLParserALTER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6973)
			p.Match(PostgreSQLParserSUBSCRIPTION)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6974)
			p.Name()
		}
		{
			p.SetState(6975)
			p.Match(PostgreSQLParserSET)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6976)
			p.Definition()
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(6978)
			p.Match(PostgreSQLParserALTER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6979)
			p.Match(PostgreSQLParserSUBSCRIPTION)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6980)
			p.Name()
		}
		{
			p.SetState(6981)
			p.Match(PostgreSQLParserCONNECTION)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6982)
			p.Sconst()
		}

	case 3:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(6984)
			p.Match(PostgreSQLParserALTER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6985)
			p.Match(PostgreSQLParserSUBSCRIPTION)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6986)
			p.Name()
		}
		{
			p.SetState(6987)
			p.Match(PostgreSQLParserREFRESH)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6988)
			p.Match(PostgreSQLParserPUBLICATION)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6989)
			p.Opt_definition()
		}

	case 4:
		p.EnterOuterAlt(localctx, 4)
		{
			p.SetState(6991)
			p.Match(PostgreSQLParserALTER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6992)
			p.Match(PostgreSQLParserSUBSCRIPTION)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6993)
			p.Name()
		}
		{
			p.SetState(6994)
			p.Match(PostgreSQLParserSET)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6995)
			p.Match(PostgreSQLParserPUBLICATION)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(6996)
			p.Publication_name_list()
		}
		{
			p.SetState(6997)
			p.Opt_definition()
		}

	case 5:
		p.EnterOuterAlt(localctx, 5)
		{
			p.SetState(6999)
			p.Match(PostgreSQLParserALTER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(7000)
			p.Match(PostgreSQLParserSUBSCRIPTION)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(7001)
			p.Name()
		}
		{
			p.SetState(7002)
			p.Match(PostgreSQLParserENABLE_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 6:
		p.EnterOuterAlt(localctx, 6)
		{
			p.SetState(7004)
			p.Match(PostgreSQLParserALTER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(7005)
			p.Match(PostgreSQLParserSUBSCRIPTION)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(7006)
			p.Name()
		}
		{
			p.SetState(7007)
			p.Match(PostgreSQLParserDISABLE_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case antlr.ATNInvalidAltNumber:
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IDropsubscriptionstmtContext is an interface to support dynamic dispatch.
type IDropsubscriptionstmtContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	DROP() antlr.TerminalNode
	SUBSCRIPTION() antlr.TerminalNode
	Name() INameContext
	Opt_drop_behavior() IOpt_drop_behaviorContext
	IF_P() antlr.TerminalNode
	EXISTS() antlr.TerminalNode

	// IsDropsubscriptionstmtContext differentiates from other interfaces.
	IsDropsubscriptionstmtContext()
}

type DropsubscriptionstmtContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyDropsubscriptionstmtContext() *DropsubscriptionstmtContext {
	var p = new(DropsubscriptionstmtContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_dropsubscriptionstmt
	return p
}

func InitEmptyDropsubscriptionstmtContext(p *DropsubscriptionstmtContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_dropsubscriptionstmt
}

func (*DropsubscriptionstmtContext) IsDropsubscriptionstmtContext() {}

func NewDropsubscriptionstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DropsubscriptionstmtContext {
	var p = new(DropsubscriptionstmtContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_dropsubscriptionstmt

	return p
}

func (s *DropsubscriptionstmtContext) GetParser() antlr.Parser { return s.parser }

func (s *DropsubscriptionstmtContext) DROP() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserDROP, 0)
}

func (s *DropsubscriptionstmtContext) SUBSCRIPTION() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserSUBSCRIPTION, 0)
}

func (s *DropsubscriptionstmtContext) Name() INameContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(INameContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(INameContext)
}

func (s *DropsubscriptionstmtContext) Opt_drop_behavior() IOpt_drop_behaviorContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOpt_drop_behaviorContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOpt_drop_behaviorContext)
}

func (s *DropsubscriptionstmtContext) IF_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserIF_P, 0)
}

func (s *DropsubscriptionstmtContext) EXISTS() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserEXISTS, 0)
}

func (s *DropsubscriptionstmtContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *DropsubscriptionstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *DropsubscriptionstmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterDropsubscriptionstmt(s)
	}
}

func (s *DropsubscriptionstmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitDropsubscriptionstmt(s)
	}
}

func (s *DropsubscriptionstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitDropsubscriptionstmt(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Dropsubscriptionstmt() (localctx IDropsubscriptionstmtContext) {
	localctx = NewDropsubscriptionstmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 762, PostgreSQLParserRULE_dropsubscriptionstmt)
	p.SetState(7023)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 325, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(7011)
			p.Match(PostgreSQLParserDROP)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(7012)
			p.Match(PostgreSQLParserSUBSCRIPTION)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(7013)
			p.Name()
		}
		{
			p.SetState(7014)
			p.Opt_drop_behavior()
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(7016)
			p.Match(PostgreSQLParserDROP)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(7017)
			p.Match(PostgreSQLParserSUBSCRIPTION)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(7018)
			p.Match(PostgreSQLParserIF_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(7019)
			p.Match(PostgreSQLParserEXISTS)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(7020)
			p.Name()
		}
		{
			p.SetState(7021)
			p.Opt_drop_behavior()
		}

	case antlr.ATNInvalidAltNumber:
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IRulestmtContext is an interface to support dynamic dispatch.
type IRulestmtContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	CREATE() antlr.TerminalNode
	Opt_or_replace() IOpt_or_replaceContext
	RULE() antlr.TerminalNode
	Name() INameContext
	AS() antlr.TerminalNode
	ON() antlr.TerminalNode
	Event() IEventContext
	TO() antlr.TerminalNode
	Qualified_name() IQualified_nameContext
	Where_clause() IWhere_clauseContext
	DO() antlr.TerminalNode
	Opt_instead() IOpt_insteadContext
	Ruleactionlist() IRuleactionlistContext

	// IsRulestmtContext differentiates from other interfaces.
	IsRulestmtContext()
}

type RulestmtContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyRulestmtContext() *RulestmtContext {
	var p = new(RulestmtContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_rulestmt
	return p
}

func InitEmptyRulestmtContext(p *RulestmtContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_rulestmt
}

func (*RulestmtContext) IsRulestmtContext() {}

func NewRulestmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *RulestmtContext {
	var p = new(RulestmtContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_rulestmt

	return p
}

func (s *RulestmtContext) GetParser() antlr.Parser { return s.parser }

func (s *RulestmtContext) CREATE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCREATE, 0)
}

func (s *RulestmtContext) Opt_or_replace() IOpt_or_replaceContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOpt_or_replaceContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOpt_or_replaceContext)
}

func (s *RulestmtContext) RULE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserRULE, 0)
}

func (s *RulestmtContext) Name() INameContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(INameContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(INameContext)
}

func (s *RulestmtContext) AS() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserAS, 0)
}

func (s *RulestmtContext) ON() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserON, 0)
}

func (s *RulestmtContext) Event() IEventContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IEventContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IEventContext)
}

func (s *RulestmtContext) TO() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserTO, 0)
}

func (s *RulestmtContext) Qualified_name() IQualified_nameContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IQualified_nameContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IQualified_nameContext)
}

func (s *RulestmtContext) Where_clause() IWhere_clauseContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IWhere_clauseContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IWhere_clauseContext)
}

func (s *RulestmtContext) DO() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserDO, 0)
}

func (s *RulestmtContext) Opt_instead() IOpt_insteadContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOpt_insteadContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOpt_insteadContext)
}

func (s *RulestmtContext) Ruleactionlist() IRuleactionlistContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IRuleactionlistContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IRuleactionlistContext)
}

func (s *RulestmtContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *RulestmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *RulestmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterRulestmt(s)
	}
}

func (s *RulestmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitRulestmt(s)
	}
}

func (s *RulestmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitRulestmt(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Rulestmt() (localctx IRulestmtContext) {
	localctx = NewRulestmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 764, PostgreSQLParserRULE_rulestmt)
	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(7025)
		p.Match(PostgreSQLParserCREATE)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(7026)
		p.Opt_or_replace()
	}
	{
		p.SetState(7027)
		p.Match(PostgreSQLParserRULE)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(7028)
		p.Name()
	}
	{
		p.SetState(7029)
		p.Match(PostgreSQLParserAS)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(7030)
		p.Match(PostgreSQLParserON)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(7031)
		p.Event()
	}
	{
		p.SetState(7032)
		p.Match(PostgreSQLParserTO)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(7033)
		p.Qualified_name()
	}
	{
		p.SetState(7034)
		p.Where_clause()
	}
	{
		p.SetState(7035)
		p.Match(PostgreSQLParserDO)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(7036)
		p.Opt_instead()
	}
	{
		p.SetState(7037)
		p.Ruleactionlist()
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IRuleactionlistContext is an interface to support dynamic dispatch.
type IRuleactionlistContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	NOTHING() antlr.TerminalNode
	Ruleactionstmt() IRuleactionstmtContext
	OPEN_PAREN() antlr.TerminalNode
	Ruleactionmulti() IRuleactionmultiContext
	CLOSE_PAREN() antlr.TerminalNode

	// IsRuleactionlistContext differentiates from other interfaces.
	IsRuleactionlistContext()
}

type RuleactionlistContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyRuleactionlistContext() *RuleactionlistContext {
	var p = new(RuleactionlistContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_ruleactionlist
	return p
}

func InitEmptyRuleactionlistContext(p *RuleactionlistContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_ruleactionlist
}

func (*RuleactionlistContext) IsRuleactionlistContext() {}

func NewRuleactionlistContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *RuleactionlistContext {
	var p = new(RuleactionlistContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_ruleactionlist

	return p
}

func (s *RuleactionlistContext) GetParser() antlr.Parser { return s.parser }

func (s *RuleactionlistContext) NOTHING() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserNOTHING, 0)
}

func (s *RuleactionlistContext) Ruleactionstmt() IRuleactionstmtContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IRuleactionstmtContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IRuleactionstmtContext)
}

func (s *RuleactionlistContext) OPEN_PAREN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserOPEN_PAREN, 0)
}

func (s *RuleactionlistContext) Ruleactionmulti() IRuleactionmultiContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IRuleactionmultiContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IRuleactionmultiContext)
}

func (s *RuleactionlistContext) CLOSE_PAREN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCLOSE_PAREN, 0)
}

func (s *RuleactionlistContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *RuleactionlistContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *RuleactionlistContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterRuleactionlist(s)
	}
}

func (s *RuleactionlistContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitRuleactionlist(s)
	}
}

func (s *RuleactionlistContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitRuleactionlist(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Ruleactionlist() (localctx IRuleactionlistContext) {
	localctx = NewRuleactionlistContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 766, PostgreSQLParserRULE_ruleactionlist)
	p.SetState(7045)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 326, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(7039)
			p.Match(PostgreSQLParserNOTHING)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(7040)
			p.Ruleactionstmt()
		}

	case 3:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(7041)
			p.Match(PostgreSQLParserOPEN_PAREN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(7042)
			p.Ruleactionmulti()
		}
		{
			p.SetState(7043)
			p.Match(PostgreSQLParserCLOSE_PAREN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case antlr.ATNInvalidAltNumber:
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IRuleactionmultiContext is an interface to support dynamic dispatch.
type IRuleactionmultiContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	AllRuleactionstmtOrEmpty() []IRuleactionstmtOrEmptyContext
	RuleactionstmtOrEmpty(i int) IRuleactionstmtOrEmptyContext
	AllSEMI() []antlr.TerminalNode
	SEMI(i int) antlr.TerminalNode

	// IsRuleactionmultiContext differentiates from other interfaces.
	IsRuleactionmultiContext()
}

type RuleactionmultiContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyRuleactionmultiContext() *RuleactionmultiContext {
	var p = new(RuleactionmultiContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_ruleactionmulti
	return p
}

func InitEmptyRuleactionmultiContext(p *RuleactionmultiContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_ruleactionmulti
}

func (*RuleactionmultiContext) IsRuleactionmultiContext() {}

func NewRuleactionmultiContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *RuleactionmultiContext {
	var p = new(RuleactionmultiContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_ruleactionmulti

	return p
}

func (s *RuleactionmultiContext) GetParser() antlr.Parser { return s.parser }

func (s *RuleactionmultiContext) AllRuleactionstmtOrEmpty() []IRuleactionstmtOrEmptyContext {
	children := s.GetChildren()
	len := 0
	for _, ctx := range children {
		if _, ok := ctx.(IRuleactionstmtOrEmptyContext); ok {
			len++
		}
	}

	tst := make([]IRuleactionstmtOrEmptyContext, len)
	i := 0
	for _, ctx := range children {
		if t, ok := ctx.(IRuleactionstmtOrEmptyContext); ok {
			tst[i] = t.(IRuleactionstmtOrEmptyContext)
			i++
		}
	}

	return tst
}

func (s *RuleactionmultiContext) RuleactionstmtOrEmpty(i int) IRuleactionstmtOrEmptyContext {
	var t antlr.RuleContext
	j := 0
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IRuleactionstmtOrEmptyContext); ok {
			if j == i {
				t = ctx.(antlr.RuleContext)
				break
			}
			j++
		}
	}

	if t == nil {
		return nil
	}

	return t.(IRuleactionstmtOrEmptyContext)
}

func (s *RuleactionmultiContext) AllSEMI() []antlr.TerminalNode {
	return s.GetTokens(PostgreSQLParserSEMI)
}

func (s *RuleactionmultiContext) SEMI(i int) antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserSEMI, i)
}

func (s *RuleactionmultiContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *RuleactionmultiContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *RuleactionmultiContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterRuleactionmulti(s)
	}
}

func (s *RuleactionmultiContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitRuleactionmulti(s)
	}
}

func (s *RuleactionmultiContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitRuleactionmulti(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Ruleactionmulti() (localctx IRuleactionmultiContext) {
	localctx = NewRuleactionmultiContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 768, PostgreSQLParserRULE_ruleactionmulti)
	var _la int

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(7047)
		p.RuleactionstmtOrEmpty()
	}
	p.SetState(7052)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}
	_la = p.GetTokenStream().LA(1)

	for _la == PostgreSQLParserSEMI {
		{
			p.SetState(7048)
			p.Match(PostgreSQLParserSEMI)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(7049)
			p.RuleactionstmtOrEmpty()
		}

		p.SetState(7054)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}
		_la = p.GetTokenStream().LA(1)
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IRuleactionstmtContext is an interface to support dynamic dispatch.
type IRuleactionstmtContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Selectstmt() ISelectstmtContext
	Insertstmt() IInsertstmtContext
	Updatestmt() IUpdatestmtContext
	Deletestmt() IDeletestmtContext
	Notifystmt() INotifystmtContext

	// IsRuleactionstmtContext differentiates from other interfaces.
	IsRuleactionstmtContext()
}

type RuleactionstmtContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyRuleactionstmtContext() *RuleactionstmtContext {
	var p = new(RuleactionstmtContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_ruleactionstmt
	return p
}

func InitEmptyRuleactionstmtContext(p *RuleactionstmtContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_ruleactionstmt
}

func (*RuleactionstmtContext) IsRuleactionstmtContext() {}

func NewRuleactionstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *RuleactionstmtContext {
	var p = new(RuleactionstmtContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_ruleactionstmt

	return p
}

func (s *RuleactionstmtContext) GetParser() antlr.Parser { return s.parser }

func (s *RuleactionstmtContext) Selectstmt() ISelectstmtContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ISelectstmtContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ISelectstmtContext)
}

func (s *RuleactionstmtContext) Insertstmt() IInsertstmtContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IInsertstmtContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IInsertstmtContext)
}

func (s *RuleactionstmtContext) Updatestmt() IUpdatestmtContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IUpdatestmtContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IUpdatestmtContext)
}

func (s *RuleactionstmtContext) Deletestmt() IDeletestmtContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IDeletestmtContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IDeletestmtContext)
}

func (s *RuleactionstmtContext) Notifystmt() INotifystmtContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(INotifystmtContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(INotifystmtContext)
}

func (s *RuleactionstmtContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *RuleactionstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *RuleactionstmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterRuleactionstmt(s)
	}
}

func (s *RuleactionstmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitRuleactionstmt(s)
	}
}

func (s *RuleactionstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitRuleactionstmt(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Ruleactionstmt() (localctx IRuleactionstmtContext) {
	localctx = NewRuleactionstmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 770, PostgreSQLParserRULE_ruleactionstmt)
	p.SetState(7060)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 328, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(7055)
			p.Selectstmt()
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(7056)
			p.Insertstmt()
		}

	case 3:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(7057)
			p.Updatestmt()
		}

	case 4:
		p.EnterOuterAlt(localctx, 4)
		{
			p.SetState(7058)
			p.Deletestmt()
		}

	case 5:
		p.EnterOuterAlt(localctx, 5)
		{
			p.SetState(7059)
			p.Notifystmt()
		}

	case antlr.ATNInvalidAltNumber:
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IRuleactionstmtOrEmptyContext is an interface to support dynamic dispatch.
type IRuleactionstmtOrEmptyContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Ruleactionstmt() IRuleactionstmtContext

	// IsRuleactionstmtOrEmptyContext differentiates from other interfaces.
	IsRuleactionstmtOrEmptyContext()
}

type RuleactionstmtOrEmptyContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyRuleactionstmtOrEmptyContext() *RuleactionstmtOrEmptyContext {
	var p = new(RuleactionstmtOrEmptyContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_ruleactionstmtOrEmpty
	return p
}

func InitEmptyRuleactionstmtOrEmptyContext(p *RuleactionstmtOrEmptyContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_ruleactionstmtOrEmpty
}

func (*RuleactionstmtOrEmptyContext) IsRuleactionstmtOrEmptyContext() {}

func NewRuleactionstmtOrEmptyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *RuleactionstmtOrEmptyContext {
	var p = new(RuleactionstmtOrEmptyContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_ruleactionstmtOrEmpty

	return p
}

func (s *RuleactionstmtOrEmptyContext) GetParser() antlr.Parser { return s.parser }

func (s *RuleactionstmtOrEmptyContext) Ruleactionstmt() IRuleactionstmtContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IRuleactionstmtContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IRuleactionstmtContext)
}

func (s *RuleactionstmtOrEmptyContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *RuleactionstmtOrEmptyContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *RuleactionstmtOrEmptyContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterRuleactionstmtOrEmpty(s)
	}
}

func (s *RuleactionstmtOrEmptyContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitRuleactionstmtOrEmpty(s)
	}
}

func (s *RuleactionstmtOrEmptyContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitRuleactionstmtOrEmpty(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) RuleactionstmtOrEmpty() (localctx IRuleactionstmtOrEmptyContext) {
	localctx = NewRuleactionstmtOrEmptyContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 772, PostgreSQLParserRULE_ruleactionstmtOrEmpty)
	p.SetState(7064)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetTokenStream().LA(1) {
	case PostgreSQLParserOPEN_PAREN, PostgreSQLParserSELECT, PostgreSQLParserTABLE, PostgreSQLParserWITH, PostgreSQLParserDELETE_P, PostgreSQLParserINSERT, PostgreSQLParserNOTIFY, PostgreSQLParserUPDATE, PostgreSQLParserVALUES:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(7062)
			p.Ruleactionstmt()
		}

	case PostgreSQLParserCLOSE_PAREN, PostgreSQLParserSEMI:
		p.EnterOuterAlt(localctx, 2)

	default:
		p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IEventContext is an interface to support dynamic dispatch.
type IEventContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	SELECT() antlr.TerminalNode
	UPDATE() antlr.TerminalNode
	DELETE_P() antlr.TerminalNode
	INSERT() antlr.TerminalNode

	// IsEventContext differentiates from other interfaces.
	IsEventContext()
}

type EventContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyEventContext() *EventContext {
	var p = new(EventContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_event
	return p
}

func InitEmptyEventContext(p *EventContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_event
}

func (*EventContext) IsEventContext() {}

func NewEventContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *EventContext {
	var p = new(EventContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_event

	return p
}

func (s *EventContext) GetParser() antlr.Parser { return s.parser }

func (s *EventContext) SELECT() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserSELECT, 0)
}

func (s *EventContext) UPDATE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserUPDATE, 0)
}

func (s *EventContext) DELETE_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserDELETE_P, 0)
}

func (s *EventContext) INSERT() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserINSERT, 0)
}

func (s *EventContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *EventContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *EventContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterEvent(s)
	}
}

func (s *EventContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitEvent(s)
	}
}

func (s *EventContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitEvent(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Event() (localctx IEventContext) {
	localctx = NewEventContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 774, PostgreSQLParserRULE_event)
	var _la int

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(7066)
		_la = p.GetTokenStream().LA(1)

		if !(_la == PostgreSQLParserSELECT || _la == PostgreSQLParserDELETE_P || _la == PostgreSQLParserINSERT || _la == PostgreSQLParserUPDATE) {
			p.GetErrorHandler().RecoverInline(p)
		} else {
			p.GetErrorHandler().ReportMatch(p)
			p.Consume()
		}
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IOpt_insteadContext is an interface to support dynamic dispatch.
type IOpt_insteadContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	INSTEAD() antlr.TerminalNode
	ALSO() antlr.TerminalNode

	// IsOpt_insteadContext differentiates from other interfaces.
	IsOpt_insteadContext()
}

type Opt_insteadContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyOpt_insteadContext() *Opt_insteadContext {
	var p = new(Opt_insteadContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opt_instead
	return p
}

func InitEmptyOpt_insteadContext(p *Opt_insteadContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opt_instead
}

func (*Opt_insteadContext) IsOpt_insteadContext() {}

func NewOpt_insteadContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_insteadContext {
	var p = new(Opt_insteadContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_opt_instead

	return p
}

func (s *Opt_insteadContext) GetParser() antlr.Parser { return s.parser }

func (s *Opt_insteadContext) INSTEAD() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserINSTEAD, 0)
}

func (s *Opt_insteadContext) ALSO() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserALSO, 0)
}

func (s *Opt_insteadContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Opt_insteadContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Opt_insteadContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterOpt_instead(s)
	}
}

func (s *Opt_insteadContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitOpt_instead(s)
	}
}

func (s *Opt_insteadContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitOpt_instead(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Opt_instead() (localctx IOpt_insteadContext) {
	localctx = NewOpt_insteadContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 776, PostgreSQLParserRULE_opt_instead)
	p.SetState(7071)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetTokenStream().LA(1) {
	case PostgreSQLParserINSTEAD:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(7068)
			p.Match(PostgreSQLParserINSTEAD)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case PostgreSQLParserALSO:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(7069)
			p.Match(PostgreSQLParserALSO)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case PostgreSQLParserOPEN_PAREN, PostgreSQLParserSELECT, PostgreSQLParserTABLE, PostgreSQLParserWITH, PostgreSQLParserDELETE_P, PostgreSQLParserINSERT, PostgreSQLParserNOTHING, PostgreSQLParserNOTIFY, PostgreSQLParserUPDATE, PostgreSQLParserVALUES:
		p.EnterOuterAlt(localctx, 3)

	default:
		p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// INotifystmtContext is an interface to support dynamic dispatch.
type INotifystmtContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	NOTIFY() antlr.TerminalNode
	Colid() IColidContext
	Notify_payload() INotify_payloadContext

	// IsNotifystmtContext differentiates from other interfaces.
	IsNotifystmtContext()
}

type NotifystmtContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyNotifystmtContext() *NotifystmtContext {
	var p = new(NotifystmtContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_notifystmt
	return p
}

func InitEmptyNotifystmtContext(p *NotifystmtContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_notifystmt
}

func (*NotifystmtContext) IsNotifystmtContext() {}

func NewNotifystmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *NotifystmtContext {
	var p = new(NotifystmtContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_notifystmt

	return p
}

func (s *NotifystmtContext) GetParser() antlr.Parser { return s.parser }

func (s *NotifystmtContext) NOTIFY() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserNOTIFY, 0)
}

func (s *NotifystmtContext) Colid() IColidContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IColidContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IColidContext)
}

func (s *NotifystmtContext) Notify_payload() INotify_payloadContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(INotify_payloadContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(INotify_payloadContext)
}

func (s *NotifystmtContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *NotifystmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *NotifystmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterNotifystmt(s)
	}
}

func (s *NotifystmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitNotifystmt(s)
	}
}

func (s *NotifystmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitNotifystmt(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Notifystmt() (localctx INotifystmtContext) {
	localctx = NewNotifystmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 778, PostgreSQLParserRULE_notifystmt)
	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(7073)
		p.Match(PostgreSQLParserNOTIFY)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(7074)
		p.Colid()
	}
	{
		p.SetState(7075)
		p.Notify_payload()
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// INotify_payloadContext is an interface to support dynamic dispatch.
type INotify_payloadContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	COMMA() antlr.TerminalNode
	Sconst() ISconstContext

	// IsNotify_payloadContext differentiates from other interfaces.
	IsNotify_payloadContext()
}

type Notify_payloadContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyNotify_payloadContext() *Notify_payloadContext {
	var p = new(Notify_payloadContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_notify_payload
	return p
}

func InitEmptyNotify_payloadContext(p *Notify_payloadContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_notify_payload
}

func (*Notify_payloadContext) IsNotify_payloadContext() {}

func NewNotify_payloadContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Notify_payloadContext {
	var p = new(Notify_payloadContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_notify_payload

	return p
}

func (s *Notify_payloadContext) GetParser() antlr.Parser { return s.parser }

func (s *Notify_payloadContext) COMMA() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCOMMA, 0)
}

func (s *Notify_payloadContext) Sconst() ISconstContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ISconstContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ISconstContext)
}

func (s *Notify_payloadContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Notify_payloadContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Notify_payloadContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterNotify_payload(s)
	}
}

func (s *Notify_payloadContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitNotify_payload(s)
	}
}

func (s *Notify_payloadContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitNotify_payload(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Notify_payload() (localctx INotify_payloadContext) {
	localctx = NewNotify_payloadContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 780, PostgreSQLParserRULE_notify_payload)
	p.SetState(7080)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetTokenStream().LA(1) {
	case PostgreSQLParserCOMMA:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(7077)
			p.Match(PostgreSQLParserCOMMA)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(7078)
			p.Sconst()
		}

	case PostgreSQLParserEOF, PostgreSQLParserOPEN_PAREN, PostgreSQLParserCLOSE_PAREN, PostgreSQLParserSEMI, PostgreSQLParserANALYSE, PostgreSQLParserANALYZE, PostgreSQLParserCREATE, PostgreSQLParserDO, PostgreSQLParserFETCH, PostgreSQLParserGRANT, PostgreSQLParserINTO, PostgreSQLParserSELECT, PostgreSQLParserTABLE, PostgreSQLParserWITH, PostgreSQLParserABORT_P, PostgreSQLParserALTER, PostgreSQLParserBEGIN_P, PostgreSQLParserCHECKPOINT, PostgreSQLParserCLOSE, PostgreSQLParserCLUSTER, PostgreSQLParserCOMMENT, PostgreSQLParserCOMMIT, PostgreSQLParserCOPY, PostgreSQLParserDEALLOCATE, PostgreSQLParserDECLARE, PostgreSQLParserDELETE_P, PostgreSQLParserDISCARD, PostgreSQLParserDROP, PostgreSQLParserEXECUTE, PostgreSQLParserEXPLAIN, PostgreSQLParserINSERT, PostgreSQLParserLISTEN, PostgreSQLParserLOAD, PostgreSQLParserLOCK_P, PostgreSQLParserMERGE, PostgreSQLParserMOVE, PostgreSQLParserNOTIFY, PostgreSQLParserPREPARE, PostgreSQLParserREASSIGN, PostgreSQLParserREFRESH, PostgreSQLParserREINDEX, PostgreSQLParserRELEASE, PostgreSQLParserRESET, PostgreSQLParserREVOKE, PostgreSQLParserROLLBACK, PostgreSQLParserSAVEPOINT, PostgreSQLParserSECURITY, PostgreSQLParserSET, PostgreSQLParserSHOW, PostgreSQLParserSTART, PostgreSQLParserTRUNCATE, PostgreSQLParserUNLISTEN, PostgreSQLParserUPDATE, PostgreSQLParserVACUUM, PostgreSQLParserVALUES, PostgreSQLParserCALL, PostgreSQLParserIMPORT_P, PostgreSQLParserEND_P, PostgreSQLParserMetaCommand:
		p.EnterOuterAlt(localctx, 2)

	default:
		p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IListenstmtContext is an interface to support dynamic dispatch.
type IListenstmtContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	LISTEN() antlr.TerminalNode
	Colid() IColidContext

	// IsListenstmtContext differentiates from other interfaces.
	IsListenstmtContext()
}

type ListenstmtContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyListenstmtContext() *ListenstmtContext {
	var p = new(ListenstmtContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_listenstmt
	return p
}

func InitEmptyListenstmtContext(p *ListenstmtContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_listenstmt
}

func (*ListenstmtContext) IsListenstmtContext() {}

func NewListenstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ListenstmtContext {
	var p = new(ListenstmtContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_listenstmt

	return p
}

func (s *ListenstmtContext) GetParser() antlr.Parser { return s.parser }

func (s *ListenstmtContext) LISTEN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserLISTEN, 0)
}

func (s *ListenstmtContext) Colid() IColidContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IColidContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IColidContext)
}

func (s *ListenstmtContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *ListenstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *ListenstmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterListenstmt(s)
	}
}

func (s *ListenstmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitListenstmt(s)
	}
}

func (s *ListenstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitListenstmt(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Listenstmt() (localctx IListenstmtContext) {
	localctx = NewListenstmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 782, PostgreSQLParserRULE_listenstmt)
	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(7082)
		p.Match(PostgreSQLParserLISTEN)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(7083)
		p.Colid()
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IUnlistenstmtContext is an interface to support dynamic dispatch.
type IUnlistenstmtContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	UNLISTEN() antlr.TerminalNode
	Colid() IColidContext
	STAR() antlr.TerminalNode

	// IsUnlistenstmtContext differentiates from other interfaces.
	IsUnlistenstmtContext()
}

type UnlistenstmtContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyUnlistenstmtContext() *UnlistenstmtContext {
	var p = new(UnlistenstmtContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_unlistenstmt
	return p
}

func InitEmptyUnlistenstmtContext(p *UnlistenstmtContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_unlistenstmt
}

func (*UnlistenstmtContext) IsUnlistenstmtContext() {}

func NewUnlistenstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *UnlistenstmtContext {
	var p = new(UnlistenstmtContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_unlistenstmt

	return p
}

func (s *UnlistenstmtContext) GetParser() antlr.Parser { return s.parser }

func (s *UnlistenstmtContext) UNLISTEN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserUNLISTEN, 0)
}

func (s *UnlistenstmtContext) Colid() IColidContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IColidContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IColidContext)
}

func (s *UnlistenstmtContext) STAR() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserSTAR, 0)
}

func (s *UnlistenstmtContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *UnlistenstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *UnlistenstmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterUnlistenstmt(s)
	}
}

func (s *UnlistenstmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitUnlistenstmt(s)
	}
}

func (s *UnlistenstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitUnlistenstmt(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Unlistenstmt() (localctx IUnlistenstmtContext) {
	localctx = NewUnlistenstmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 784, PostgreSQLParserRULE_unlistenstmt)
	p.SetState(7089)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 332, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(7085)
			p.Match(PostgreSQLParserUNLISTEN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(7086)
			p.Colid()
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(7087)
			p.Match(PostgreSQLParserUNLISTEN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(7088)
			p.Match(PostgreSQLParserSTAR)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case antlr.ATNInvalidAltNumber:
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// ITransactionstmtContext is an interface to support dynamic dispatch.
type ITransactionstmtContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	ABORT_P() antlr.TerminalNode
	Opt_transaction() IOpt_transactionContext
	Opt_transaction_chain() IOpt_transaction_chainContext
	BEGIN_P() antlr.TerminalNode
	Transaction_mode_list_or_empty() ITransaction_mode_list_or_emptyContext
	START() antlr.TerminalNode
	TRANSACTION() antlr.TerminalNode
	COMMIT() antlr.TerminalNode
	END_P() antlr.TerminalNode
	ROLLBACK() antlr.TerminalNode
	SAVEPOINT() antlr.TerminalNode
	Colid() IColidContext
	RELEASE() antlr.TerminalNode
	TO() antlr.TerminalNode
	PREPARE() antlr.TerminalNode
	Sconst() ISconstContext
	PREPARED() antlr.TerminalNode

	// IsTransactionstmtContext differentiates from other interfaces.
	IsTransactionstmtContext()
}

type TransactionstmtContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyTransactionstmtContext() *TransactionstmtContext {
	var p = new(TransactionstmtContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_transactionstmt
	return p
}

func InitEmptyTransactionstmtContext(p *TransactionstmtContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_transactionstmt
}

func (*TransactionstmtContext) IsTransactionstmtContext() {}

func NewTransactionstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TransactionstmtContext {
	var p = new(TransactionstmtContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_transactionstmt

	return p
}

func (s *TransactionstmtContext) GetParser() antlr.Parser { return s.parser }

func (s *TransactionstmtContext) ABORT_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserABORT_P, 0)
}

func (s *TransactionstmtContext) Opt_transaction() IOpt_transactionContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOpt_transactionContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOpt_transactionContext)
}

func (s *TransactionstmtContext) Opt_transaction_chain() IOpt_transaction_chainContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOpt_transaction_chainContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOpt_transaction_chainContext)
}

func (s *TransactionstmtContext) BEGIN_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserBEGIN_P, 0)
}

func (s *TransactionstmtContext) Transaction_mode_list_or_empty() ITransaction_mode_list_or_emptyContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ITransaction_mode_list_or_emptyContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ITransaction_mode_list_or_emptyContext)
}

func (s *TransactionstmtContext) START() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserSTART, 0)
}

func (s *TransactionstmtContext) TRANSACTION() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserTRANSACTION, 0)
}

func (s *TransactionstmtContext) COMMIT() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCOMMIT, 0)
}

func (s *TransactionstmtContext) END_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserEND_P, 0)
}

func (s *TransactionstmtContext) ROLLBACK() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserROLLBACK, 0)
}

func (s *TransactionstmtContext) SAVEPOINT() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserSAVEPOINT, 0)
}

func (s *TransactionstmtContext) Colid() IColidContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IColidContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IColidContext)
}

func (s *TransactionstmtContext) RELEASE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserRELEASE, 0)
}

func (s *TransactionstmtContext) TO() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserTO, 0)
}

func (s *TransactionstmtContext) PREPARE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserPREPARE, 0)
}

func (s *TransactionstmtContext) Sconst() ISconstContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ISconstContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ISconstContext)
}

func (s *TransactionstmtContext) PREPARED() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserPREPARED, 0)
}

func (s *TransactionstmtContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *TransactionstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *TransactionstmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterTransactionstmt(s)
	}
}

func (s *TransactionstmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitTransactionstmt(s)
	}
}

func (s *TransactionstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitTransactionstmt(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Transactionstmt() (localctx ITransactionstmtContext) {
	localctx = NewTransactionstmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 786, PostgreSQLParserRULE_transactionstmt)
	p.SetState(7141)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 333, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(7091)
			p.Match(PostgreSQLParserABORT_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(7092)
			p.Opt_transaction()
		}
		{
			p.SetState(7093)
			p.Opt_transaction_chain()
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(7095)
			p.Match(PostgreSQLParserBEGIN_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(7096)
			p.Opt_transaction()
		}
		{
			p.SetState(7097)
			p.Transaction_mode_list_or_empty()
		}

	case 3:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(7099)
			p.Match(PostgreSQLParserSTART)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(7100)
			p.Match(PostgreSQLParserTRANSACTION)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(7101)
			p.Transaction_mode_list_or_empty()
		}

	case 4:
		p.EnterOuterAlt(localctx, 4)
		{
			p.SetState(7102)
			p.Match(PostgreSQLParserCOMMIT)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(7103)
			p.Opt_transaction()
		}
		{
			p.SetState(7104)
			p.Opt_transaction_chain()
		}

	case 5:
		p.EnterOuterAlt(localctx, 5)
		{
			p.SetState(7106)
			p.Match(PostgreSQLParserEND_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(7107)
			p.Opt_transaction()
		}
		{
			p.SetState(7108)
			p.Opt_transaction_chain()
		}

	case 6:
		p.EnterOuterAlt(localctx, 6)
		{
			p.SetState(7110)
			p.Match(PostgreSQLParserROLLBACK)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(7111)
			p.Opt_transaction()
		}
		{
			p.SetState(7112)
			p.Opt_transaction_chain()
		}

	case 7:
		p.EnterOuterAlt(localctx, 7)
		{
			p.SetState(7114)
			p.Match(PostgreSQLParserSAVEPOINT)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(7115)
			p.Colid()
		}

	case 8:
		p.EnterOuterAlt(localctx, 8)
		{
			p.SetState(7116)
			p.Match(PostgreSQLParserRELEASE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(7117)
			p.Match(PostgreSQLParserSAVEPOINT)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(7118)
			p.Colid()
		}

	case 9:
		p.EnterOuterAlt(localctx, 9)
		{
			p.SetState(7119)
			p.Match(PostgreSQLParserRELEASE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(7120)
			p.Colid()
		}

	case 10:
		p.EnterOuterAlt(localctx, 10)
		{
			p.SetState(7121)
			p.Match(PostgreSQLParserROLLBACK)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(7122)
			p.Opt_transaction()
		}
		{
			p.SetState(7123)
			p.Match(PostgreSQLParserTO)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(7124)
			p.Match(PostgreSQLParserSAVEPOINT)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(7125)
			p.Colid()
		}

	case 11:
		p.EnterOuterAlt(localctx, 11)
		{
			p.SetState(7127)
			p.Match(PostgreSQLParserROLLBACK)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(7128)
			p.Opt_transaction()
		}
		{
			p.SetState(7129)
			p.Match(PostgreSQLParserTO)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(7130)
			p.Colid()
		}

	case 12:
		p.EnterOuterAlt(localctx, 12)
		{
			p.SetState(7132)
			p.Match(PostgreSQLParserPREPARE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(7133)
			p.Match(PostgreSQLParserTRANSACTION)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(7134)
			p.Sconst()
		}

	case 13:
		p.EnterOuterAlt(localctx, 13)
		{
			p.SetState(7135)
			p.Match(PostgreSQLParserCOMMIT)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(7136)
			p.Match(PostgreSQLParserPREPARED)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(7137)
			p.Sconst()
		}

	case 14:
		p.EnterOuterAlt(localctx, 14)
		{
			p.SetState(7138)
			p.Match(PostgreSQLParserROLLBACK)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(7139)
			p.Match(PostgreSQLParserPREPARED)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(7140)
			p.Sconst()
		}

	case antlr.ATNInvalidAltNumber:
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IOpt_transactionContext is an interface to support dynamic dispatch.
type IOpt_transactionContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	WORK() antlr.TerminalNode
	TRANSACTION() antlr.TerminalNode

	// IsOpt_transactionContext differentiates from other interfaces.
	IsOpt_transactionContext()
}

type Opt_transactionContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyOpt_transactionContext() *Opt_transactionContext {
	var p = new(Opt_transactionContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opt_transaction
	return p
}

func InitEmptyOpt_transactionContext(p *Opt_transactionContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opt_transaction
}

func (*Opt_transactionContext) IsOpt_transactionContext() {}

func NewOpt_transactionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_transactionContext {
	var p = new(Opt_transactionContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_opt_transaction

	return p
}

func (s *Opt_transactionContext) GetParser() antlr.Parser { return s.parser }

func (s *Opt_transactionContext) WORK() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserWORK, 0)
}

func (s *Opt_transactionContext) TRANSACTION() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserTRANSACTION, 0)
}

func (s *Opt_transactionContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Opt_transactionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Opt_transactionContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterOpt_transaction(s)
	}
}

func (s *Opt_transactionContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitOpt_transaction(s)
	}
}

func (s *Opt_transactionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitOpt_transaction(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Opt_transaction() (localctx IOpt_transactionContext) {
	localctx = NewOpt_transactionContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 788, PostgreSQLParserRULE_opt_transaction)
	p.SetState(7146)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetTokenStream().LA(1) {
	case PostgreSQLParserWORK:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(7143)
			p.Match(PostgreSQLParserWORK)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case PostgreSQLParserTRANSACTION:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(7144)
			p.Match(PostgreSQLParserTRANSACTION)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case PostgreSQLParserEOF, PostgreSQLParserOPEN_PAREN, PostgreSQLParserSEMI, PostgreSQLParserANALYSE, PostgreSQLParserANALYZE, PostgreSQLParserAND, PostgreSQLParserCREATE, PostgreSQLParserDEFERRABLE, PostgreSQLParserDO, PostgreSQLParserFETCH, PostgreSQLParserGRANT, PostgreSQLParserINTO, PostgreSQLParserNOT, PostgreSQLParserSELECT, PostgreSQLParserTABLE, PostgreSQLParserTO, PostgreSQLParserWITH, PostgreSQLParserABORT_P, PostgreSQLParserALTER, PostgreSQLParserBEGIN_P, PostgreSQLParserCHECKPOINT, PostgreSQLParserCLOSE, PostgreSQLParserCLUSTER, PostgreSQLParserCOMMENT, PostgreSQLParserCOMMIT, PostgreSQLParserCOPY, PostgreSQLParserDEALLOCATE, PostgreSQLParserDECLARE, PostgreSQLParserDELETE_P, PostgreSQLParserDISCARD, PostgreSQLParserDROP, PostgreSQLParserEXECUTE, PostgreSQLParserEXPLAIN, PostgreSQLParserINSERT, PostgreSQLParserISOLATION, PostgreSQLParserLISTEN, PostgreSQLParserLOAD, PostgreSQLParserLOCK_P, PostgreSQLParserMERGE, PostgreSQLParserMOVE, PostgreSQLParserNOTIFY, PostgreSQLParserPREPARE, PostgreSQLParserREAD, PostgreSQLParserREASSIGN, PostgreSQLParserREFRESH, PostgreSQLParserREINDEX, PostgreSQLParserRELEASE, PostgreSQLParserRESET, PostgreSQLParserREVOKE, PostgreSQLParserROLLBACK, PostgreSQLParserSAVEPOINT, PostgreSQLParserSECURITY, PostgreSQLParserSET, PostgreSQLParserSHOW, PostgreSQLParserSTART, PostgreSQLParserTRUNCATE, PostgreSQLParserUNLISTEN, PostgreSQLParserUPDATE, PostgreSQLParserVACUUM, PostgreSQLParserVALUES, PostgreSQLParserCALL, PostgreSQLParserIMPORT_P, PostgreSQLParserEND_P, PostgreSQLParserMetaCommand:
		p.EnterOuterAlt(localctx, 3)

	default:
		p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// ITransaction_mode_itemContext is an interface to support dynamic dispatch.
type ITransaction_mode_itemContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	ISOLATION() antlr.TerminalNode
	LEVEL() antlr.TerminalNode
	Iso_level() IIso_levelContext
	READ() antlr.TerminalNode
	ONLY() antlr.TerminalNode
	WRITE() antlr.TerminalNode
	DEFERRABLE() antlr.TerminalNode
	NOT() antlr.TerminalNode

	// IsTransaction_mode_itemContext differentiates from other interfaces.
	IsTransaction_mode_itemContext()
}

type Transaction_mode_itemContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyTransaction_mode_itemContext() *Transaction_mode_itemContext {
	var p = new(Transaction_mode_itemContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_transaction_mode_item
	return p
}

func InitEmptyTransaction_mode_itemContext(p *Transaction_mode_itemContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_transaction_mode_item
}

func (*Transaction_mode_itemContext) IsTransaction_mode_itemContext() {}

func NewTransaction_mode_itemContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Transaction_mode_itemContext {
	var p = new(Transaction_mode_itemContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_transaction_mode_item

	return p
}

func (s *Transaction_mode_itemContext) GetParser() antlr.Parser { return s.parser }

func (s *Transaction_mode_itemContext) ISOLATION() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserISOLATION, 0)
}

func (s *Transaction_mode_itemContext) LEVEL() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserLEVEL, 0)
}

func (s *Transaction_mode_itemContext) Iso_level() IIso_levelContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IIso_levelContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IIso_levelContext)
}

func (s *Transaction_mode_itemContext) READ() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserREAD, 0)
}

func (s *Transaction_mode_itemContext) ONLY() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserONLY, 0)
}

func (s *Transaction_mode_itemContext) WRITE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserWRITE, 0)
}

func (s *Transaction_mode_itemContext) DEFERRABLE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserDEFERRABLE, 0)
}

func (s *Transaction_mode_itemContext) NOT() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserNOT, 0)
}

func (s *Transaction_mode_itemContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Transaction_mode_itemContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Transaction_mode_itemContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterTransaction_mode_item(s)
	}
}

func (s *Transaction_mode_itemContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitTransaction_mode_item(s)
	}
}

func (s *Transaction_mode_itemContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitTransaction_mode_item(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Transaction_mode_item() (localctx ITransaction_mode_itemContext) {
	localctx = NewTransaction_mode_itemContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 790, PostgreSQLParserRULE_transaction_mode_item)
	p.SetState(7158)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 335, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(7148)
			p.Match(PostgreSQLParserISOLATION)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(7149)
			p.Match(PostgreSQLParserLEVEL)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(7150)
			p.Iso_level()
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(7151)
			p.Match(PostgreSQLParserREAD)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(7152)
			p.Match(PostgreSQLParserONLY)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 3:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(7153)
			p.Match(PostgreSQLParserREAD)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(7154)
			p.Match(PostgreSQLParserWRITE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 4:
		p.EnterOuterAlt(localctx, 4)
		{
			p.SetState(7155)
			p.Match(PostgreSQLParserDEFERRABLE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 5:
		p.EnterOuterAlt(localctx, 5)
		{
			p.SetState(7156)
			p.Match(PostgreSQLParserNOT)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(7157)
			p.Match(PostgreSQLParserDEFERRABLE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case antlr.ATNInvalidAltNumber:
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// ITransaction_mode_listContext is an interface to support dynamic dispatch.
type ITransaction_mode_listContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	AllTransaction_mode_item() []ITransaction_mode_itemContext
	Transaction_mode_item(i int) ITransaction_mode_itemContext
	AllCOMMA() []antlr.TerminalNode
	COMMA(i int) antlr.TerminalNode

	// IsTransaction_mode_listContext differentiates from other interfaces.
	IsTransaction_mode_listContext()
}

type Transaction_mode_listContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyTransaction_mode_listContext() *Transaction_mode_listContext {
	var p = new(Transaction_mode_listContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_transaction_mode_list
	return p
}

func InitEmptyTransaction_mode_listContext(p *Transaction_mode_listContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_transaction_mode_list
}

func (*Transaction_mode_listContext) IsTransaction_mode_listContext() {}

func NewTransaction_mode_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Transaction_mode_listContext {
	var p = new(Transaction_mode_listContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_transaction_mode_list

	return p
}

func (s *Transaction_mode_listContext) GetParser() antlr.Parser { return s.parser }

func (s *Transaction_mode_listContext) AllTransaction_mode_item() []ITransaction_mode_itemContext {
	children := s.GetChildren()
	len := 0
	for _, ctx := range children {
		if _, ok := ctx.(ITransaction_mode_itemContext); ok {
			len++
		}
	}

	tst := make([]ITransaction_mode_itemContext, len)
	i := 0
	for _, ctx := range children {
		if t, ok := ctx.(ITransaction_mode_itemContext); ok {
			tst[i] = t.(ITransaction_mode_itemContext)
			i++
		}
	}

	return tst
}

func (s *Transaction_mode_listContext) Transaction_mode_item(i int) ITransaction_mode_itemContext {
	var t antlr.RuleContext
	j := 0
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ITransaction_mode_itemContext); ok {
			if j == i {
				t = ctx.(antlr.RuleContext)
				break
			}
			j++
		}
	}

	if t == nil {
		return nil
	}

	return t.(ITransaction_mode_itemContext)
}

func (s *Transaction_mode_listContext) AllCOMMA() []antlr.TerminalNode {
	return s.GetTokens(PostgreSQLParserCOMMA)
}

func (s *Transaction_mode_listContext) COMMA(i int) antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCOMMA, i)
}

func (s *Transaction_mode_listContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Transaction_mode_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Transaction_mode_listContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterTransaction_mode_list(s)
	}
}

func (s *Transaction_mode_listContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitTransaction_mode_list(s)
	}
}

func (s *Transaction_mode_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitTransaction_mode_list(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Transaction_mode_list() (localctx ITransaction_mode_listContext) {
	localctx = NewTransaction_mode_listContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 792, PostgreSQLParserRULE_transaction_mode_list)
	var _la int

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(7160)
		p.Transaction_mode_item()
	}
	p.SetState(7167)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}
	_la = p.GetTokenStream().LA(1)

	for _la == PostgreSQLParserCOMMA || _la == PostgreSQLParserDEFERRABLE || _la == PostgreSQLParserNOT || _la == PostgreSQLParserISOLATION || _la == PostgreSQLParserREAD {
		p.SetState(7162)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}
		_la = p.GetTokenStream().LA(1)

		if _la == PostgreSQLParserCOMMA {
			{
				p.SetState(7161)
				p.Match(PostgreSQLParserCOMMA)
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}

		}
		{
			p.SetState(7164)
			p.Transaction_mode_item()
		}

		p.SetState(7169)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}
		_la = p.GetTokenStream().LA(1)
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// ITransaction_mode_list_or_emptyContext is an interface to support dynamic dispatch.
type ITransaction_mode_list_or_emptyContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Transaction_mode_list() ITransaction_mode_listContext

	// IsTransaction_mode_list_or_emptyContext differentiates from other interfaces.
	IsTransaction_mode_list_or_emptyContext()
}

type Transaction_mode_list_or_emptyContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyTransaction_mode_list_or_emptyContext() *Transaction_mode_list_or_emptyContext {
	var p = new(Transaction_mode_list_or_emptyContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_transaction_mode_list_or_empty
	return p
}

func InitEmptyTransaction_mode_list_or_emptyContext(p *Transaction_mode_list_or_emptyContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_transaction_mode_list_or_empty
}

func (*Transaction_mode_list_or_emptyContext) IsTransaction_mode_list_or_emptyContext() {}

func NewTransaction_mode_list_or_emptyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Transaction_mode_list_or_emptyContext {
	var p = new(Transaction_mode_list_or_emptyContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_transaction_mode_list_or_empty

	return p
}

func (s *Transaction_mode_list_or_emptyContext) GetParser() antlr.Parser { return s.parser }

func (s *Transaction_mode_list_or_emptyContext) Transaction_mode_list() ITransaction_mode_listContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ITransaction_mode_listContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ITransaction_mode_listContext)
}

func (s *Transaction_mode_list_or_emptyContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Transaction_mode_list_or_emptyContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Transaction_mode_list_or_emptyContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterTransaction_mode_list_or_empty(s)
	}
}

func (s *Transaction_mode_list_or_emptyContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitTransaction_mode_list_or_empty(s)
	}
}

func (s *Transaction_mode_list_or_emptyContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitTransaction_mode_list_or_empty(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Transaction_mode_list_or_empty() (localctx ITransaction_mode_list_or_emptyContext) {
	localctx = NewTransaction_mode_list_or_emptyContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 794, PostgreSQLParserRULE_transaction_mode_list_or_empty)
	p.SetState(7172)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetTokenStream().LA(1) {
	case PostgreSQLParserDEFERRABLE, PostgreSQLParserNOT, PostgreSQLParserISOLATION, PostgreSQLParserREAD:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(7170)
			p.Transaction_mode_list()
		}

	case PostgreSQLParserEOF, PostgreSQLParserOPEN_PAREN, PostgreSQLParserSEMI, PostgreSQLParserANALYSE, PostgreSQLParserANALYZE, PostgreSQLParserCREATE, PostgreSQLParserDO, PostgreSQLParserFETCH, PostgreSQLParserGRANT, PostgreSQLParserINTO, PostgreSQLParserSELECT, PostgreSQLParserTABLE, PostgreSQLParserWITH, PostgreSQLParserABORT_P, PostgreSQLParserALTER, PostgreSQLParserBEGIN_P, PostgreSQLParserCHECKPOINT, PostgreSQLParserCLOSE, PostgreSQLParserCLUSTER, PostgreSQLParserCOMMENT, PostgreSQLParserCOMMIT, PostgreSQLParserCOPY, PostgreSQLParserDEALLOCATE, PostgreSQLParserDECLARE, PostgreSQLParserDELETE_P, PostgreSQLParserDISCARD, PostgreSQLParserDROP, PostgreSQLParserEXECUTE, PostgreSQLParserEXPLAIN, PostgreSQLParserINSERT, PostgreSQLParserLISTEN, PostgreSQLParserLOAD, PostgreSQLParserLOCK_P, PostgreSQLParserMERGE, PostgreSQLParserMOVE, PostgreSQLParserNOTIFY, PostgreSQLParserPREPARE, PostgreSQLParserREASSIGN, PostgreSQLParserREFRESH, PostgreSQLParserREINDEX, PostgreSQLParserRELEASE, PostgreSQLParserRESET, PostgreSQLParserREVOKE, PostgreSQLParserROLLBACK, PostgreSQLParserSAVEPOINT, PostgreSQLParserSECURITY, PostgreSQLParserSET, PostgreSQLParserSHOW, PostgreSQLParserSTART, PostgreSQLParserTRUNCATE, PostgreSQLParserUNLISTEN, PostgreSQLParserUPDATE, PostgreSQLParserVACUUM, PostgreSQLParserVALUES, PostgreSQLParserCALL, PostgreSQLParserIMPORT_P, PostgreSQLParserEND_P, PostgreSQLParserMetaCommand:
		p.EnterOuterAlt(localctx, 2)

	default:
		p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IOpt_transaction_chainContext is an interface to support dynamic dispatch.
type IOpt_transaction_chainContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	AND() antlr.TerminalNode
	CHAIN() antlr.TerminalNode
	NO() antlr.TerminalNode

	// IsOpt_transaction_chainContext differentiates from other interfaces.
	IsOpt_transaction_chainContext()
}

type Opt_transaction_chainContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyOpt_transaction_chainContext() *Opt_transaction_chainContext {
	var p = new(Opt_transaction_chainContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opt_transaction_chain
	return p
}

func InitEmptyOpt_transaction_chainContext(p *Opt_transaction_chainContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opt_transaction_chain
}

func (*Opt_transaction_chainContext) IsOpt_transaction_chainContext() {}

func NewOpt_transaction_chainContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_transaction_chainContext {
	var p = new(Opt_transaction_chainContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_opt_transaction_chain

	return p
}

func (s *Opt_transaction_chainContext) GetParser() antlr.Parser { return s.parser }

func (s *Opt_transaction_chainContext) AND() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserAND, 0)
}

func (s *Opt_transaction_chainContext) CHAIN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCHAIN, 0)
}

func (s *Opt_transaction_chainContext) NO() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserNO, 0)
}

func (s *Opt_transaction_chainContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Opt_transaction_chainContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Opt_transaction_chainContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterOpt_transaction_chain(s)
	}
}

func (s *Opt_transaction_chainContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitOpt_transaction_chain(s)
	}
}

func (s *Opt_transaction_chainContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitOpt_transaction_chain(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Opt_transaction_chain() (localctx IOpt_transaction_chainContext) {
	localctx = NewOpt_transaction_chainContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 796, PostgreSQLParserRULE_opt_transaction_chain)
	var _la int

	p.SetState(7180)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetTokenStream().LA(1) {
	case PostgreSQLParserAND:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(7174)
			p.Match(PostgreSQLParserAND)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		p.SetState(7176)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}
		_la = p.GetTokenStream().LA(1)

		if _la == PostgreSQLParserNO {
			{
				p.SetState(7175)
				p.Match(PostgreSQLParserNO)
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}

		}
		{
			p.SetState(7178)
			p.Match(PostgreSQLParserCHAIN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case PostgreSQLParserEOF, PostgreSQLParserOPEN_PAREN, PostgreSQLParserSEMI, PostgreSQLParserANALYSE, PostgreSQLParserANALYZE, PostgreSQLParserCREATE, PostgreSQLParserDO, PostgreSQLParserFETCH, PostgreSQLParserGRANT, PostgreSQLParserINTO, PostgreSQLParserSELECT, PostgreSQLParserTABLE, PostgreSQLParserWITH, PostgreSQLParserABORT_P, PostgreSQLParserALTER, PostgreSQLParserBEGIN_P, PostgreSQLParserCHECKPOINT, PostgreSQLParserCLOSE, PostgreSQLParserCLUSTER, PostgreSQLParserCOMMENT, PostgreSQLParserCOMMIT, PostgreSQLParserCOPY, PostgreSQLParserDEALLOCATE, PostgreSQLParserDECLARE, PostgreSQLParserDELETE_P, PostgreSQLParserDISCARD, PostgreSQLParserDROP, PostgreSQLParserEXECUTE, PostgreSQLParserEXPLAIN, PostgreSQLParserINSERT, PostgreSQLParserLISTEN, PostgreSQLParserLOAD, PostgreSQLParserLOCK_P, PostgreSQLParserMERGE, PostgreSQLParserMOVE, PostgreSQLParserNOTIFY, PostgreSQLParserPREPARE, PostgreSQLParserREASSIGN, PostgreSQLParserREFRESH, PostgreSQLParserREINDEX, PostgreSQLParserRELEASE, PostgreSQLParserRESET, PostgreSQLParserREVOKE, PostgreSQLParserROLLBACK, PostgreSQLParserSAVEPOINT, PostgreSQLParserSECURITY, PostgreSQLParserSET, PostgreSQLParserSHOW, PostgreSQLParserSTART, PostgreSQLParserTRUNCATE, PostgreSQLParserUNLISTEN, PostgreSQLParserUPDATE, PostgreSQLParserVACUUM, PostgreSQLParserVALUES, PostgreSQLParserCALL, PostgreSQLParserIMPORT_P, PostgreSQLParserEND_P, PostgreSQLParserMetaCommand:
		p.EnterOuterAlt(localctx, 2)

	default:
		p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IViewstmtContext is an interface to support dynamic dispatch.
type IViewstmtContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	CREATE() antlr.TerminalNode
	Opttemp() IOpttempContext
	AS() antlr.TerminalNode
	Selectstmt() ISelectstmtContext
	Opt_check_option() IOpt_check_optionContext
	VIEW() antlr.TerminalNode
	Qualified_name() IQualified_nameContext
	Opt_column_list() IOpt_column_listContext
	Opt_reloptions() IOpt_reloptionsContext
	RECURSIVE() antlr.TerminalNode
	OPEN_PAREN() antlr.TerminalNode
	Columnlist() IColumnlistContext
	CLOSE_PAREN() antlr.TerminalNode
	OR() antlr.TerminalNode
	REPLACE() antlr.TerminalNode

	// IsViewstmtContext differentiates from other interfaces.
	IsViewstmtContext()
}

type ViewstmtContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyViewstmtContext() *ViewstmtContext {
	var p = new(ViewstmtContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_viewstmt
	return p
}

func InitEmptyViewstmtContext(p *ViewstmtContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_viewstmt
}

func (*ViewstmtContext) IsViewstmtContext() {}

func NewViewstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ViewstmtContext {
	var p = new(ViewstmtContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_viewstmt

	return p
}

func (s *ViewstmtContext) GetParser() antlr.Parser { return s.parser }

func (s *ViewstmtContext) CREATE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCREATE, 0)
}

func (s *ViewstmtContext) Opttemp() IOpttempContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOpttempContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOpttempContext)
}

func (s *ViewstmtContext) AS() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserAS, 0)
}

func (s *ViewstmtContext) Selectstmt() ISelectstmtContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ISelectstmtContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ISelectstmtContext)
}

func (s *ViewstmtContext) Opt_check_option() IOpt_check_optionContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOpt_check_optionContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOpt_check_optionContext)
}

func (s *ViewstmtContext) VIEW() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserVIEW, 0)
}

func (s *ViewstmtContext) Qualified_name() IQualified_nameContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IQualified_nameContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IQualified_nameContext)
}

func (s *ViewstmtContext) Opt_column_list() IOpt_column_listContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOpt_column_listContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOpt_column_listContext)
}

func (s *ViewstmtContext) Opt_reloptions() IOpt_reloptionsContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOpt_reloptionsContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOpt_reloptionsContext)
}

func (s *ViewstmtContext) RECURSIVE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserRECURSIVE, 0)
}

func (s *ViewstmtContext) OPEN_PAREN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserOPEN_PAREN, 0)
}

func (s *ViewstmtContext) Columnlist() IColumnlistContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IColumnlistContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IColumnlistContext)
}

func (s *ViewstmtContext) CLOSE_PAREN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCLOSE_PAREN, 0)
}

func (s *ViewstmtContext) OR() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserOR, 0)
}

func (s *ViewstmtContext) REPLACE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserREPLACE, 0)
}

func (s *ViewstmtContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *ViewstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *ViewstmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterViewstmt(s)
	}
}

func (s *ViewstmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitViewstmt(s)
	}
}

func (s *ViewstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitViewstmt(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Viewstmt() (localctx IViewstmtContext) {
	localctx = NewViewstmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 798, PostgreSQLParserRULE_viewstmt)
	var _la int

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(7182)
		p.Match(PostgreSQLParserCREATE)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	p.SetState(7185)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}
	_la = p.GetTokenStream().LA(1)

	if _la == PostgreSQLParserOR {
		{
			p.SetState(7183)
			p.Match(PostgreSQLParserOR)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(7184)
			p.Match(PostgreSQLParserREPLACE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	}
	{
		p.SetState(7187)
		p.Opttemp()
	}
	p.SetState(7201)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetTokenStream().LA(1) {
	case PostgreSQLParserVIEW:
		{
			p.SetState(7188)
			p.Match(PostgreSQLParserVIEW)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(7189)
			p.Qualified_name()
		}
		{
			p.SetState(7190)
			p.Opt_column_list()
		}
		{
			p.SetState(7191)
			p.Opt_reloptions()
		}

	case PostgreSQLParserRECURSIVE:
		{
			p.SetState(7193)
			p.Match(PostgreSQLParserRECURSIVE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(7194)
			p.Match(PostgreSQLParserVIEW)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(7195)
			p.Qualified_name()
		}
		{
			p.SetState(7196)
			p.Match(PostgreSQLParserOPEN_PAREN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(7197)
			p.Columnlist()
		}
		{
			p.SetState(7198)
			p.Match(PostgreSQLParserCLOSE_PAREN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(7199)
			p.Opt_reloptions()
		}

	default:
		p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		goto errorExit
	}
	{
		p.SetState(7203)
		p.Match(PostgreSQLParserAS)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(7204)
		p.Selectstmt()
	}
	{
		p.SetState(7205)
		p.Opt_check_option()
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IOpt_check_optionContext is an interface to support dynamic dispatch.
type IOpt_check_optionContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	WITH() antlr.TerminalNode
	CHECK() antlr.TerminalNode
	OPTION() antlr.TerminalNode
	CASCADED() antlr.TerminalNode
	LOCAL() antlr.TerminalNode

	// IsOpt_check_optionContext differentiates from other interfaces.
	IsOpt_check_optionContext()
}

type Opt_check_optionContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyOpt_check_optionContext() *Opt_check_optionContext {
	var p = new(Opt_check_optionContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opt_check_option
	return p
}

func InitEmptyOpt_check_optionContext(p *Opt_check_optionContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opt_check_option
}

func (*Opt_check_optionContext) IsOpt_check_optionContext() {}

func NewOpt_check_optionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_check_optionContext {
	var p = new(Opt_check_optionContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_opt_check_option

	return p
}

func (s *Opt_check_optionContext) GetParser() antlr.Parser { return s.parser }

func (s *Opt_check_optionContext) WITH() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserWITH, 0)
}

func (s *Opt_check_optionContext) CHECK() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCHECK, 0)
}

func (s *Opt_check_optionContext) OPTION() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserOPTION, 0)
}

func (s *Opt_check_optionContext) CASCADED() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCASCADED, 0)
}

func (s *Opt_check_optionContext) LOCAL() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserLOCAL, 0)
}

func (s *Opt_check_optionContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Opt_check_optionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Opt_check_optionContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterOpt_check_option(s)
	}
}

func (s *Opt_check_optionContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitOpt_check_option(s)
	}
}

func (s *Opt_check_optionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitOpt_check_option(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Opt_check_option() (localctx IOpt_check_optionContext) {
	localctx = NewOpt_check_optionContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 800, PostgreSQLParserRULE_opt_check_option)
	var _la int

	p.SetState(7214)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 344, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(7207)
			p.Match(PostgreSQLParserWITH)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		p.SetState(7209)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}
		_la = p.GetTokenStream().LA(1)

		if _la == PostgreSQLParserCASCADED || _la == PostgreSQLParserLOCAL {
			{
				p.SetState(7208)
				_la = p.GetTokenStream().LA(1)

				if !(_la == PostgreSQLParserCASCADED || _la == PostgreSQLParserLOCAL) {
					p.GetErrorHandler().RecoverInline(p)
				} else {
					p.GetErrorHandler().ReportMatch(p)
					p.Consume()
				}
			}

		}
		{
			p.SetState(7211)
			p.Match(PostgreSQLParserCHECK)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(7212)
			p.Match(PostgreSQLParserOPTION)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)

	case antlr.ATNInvalidAltNumber:
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// ILoadstmtContext is an interface to support dynamic dispatch.
type ILoadstmtContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	LOAD() antlr.TerminalNode
	File_name() IFile_nameContext

	// IsLoadstmtContext differentiates from other interfaces.
	IsLoadstmtContext()
}

type LoadstmtContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyLoadstmtContext() *LoadstmtContext {
	var p = new(LoadstmtContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_loadstmt
	return p
}

func InitEmptyLoadstmtContext(p *LoadstmtContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_loadstmt
}

func (*LoadstmtContext) IsLoadstmtContext() {}

func NewLoadstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *LoadstmtContext {
	var p = new(LoadstmtContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_loadstmt

	return p
}

func (s *LoadstmtContext) GetParser() antlr.Parser { return s.parser }

func (s *LoadstmtContext) LOAD() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserLOAD, 0)
}

func (s *LoadstmtContext) File_name() IFile_nameContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IFile_nameContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IFile_nameContext)
}

func (s *LoadstmtContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *LoadstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *LoadstmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterLoadstmt(s)
	}
}

func (s *LoadstmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitLoadstmt(s)
	}
}

func (s *LoadstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitLoadstmt(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Loadstmt() (localctx ILoadstmtContext) {
	localctx = NewLoadstmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 802, PostgreSQLParserRULE_loadstmt)
	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(7216)
		p.Match(PostgreSQLParserLOAD)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(7217)
		p.File_name()
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// ICreatedbstmtContext is an interface to support dynamic dispatch.
type ICreatedbstmtContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	CREATE() antlr.TerminalNode
	DATABASE() antlr.TerminalNode
	Name() INameContext
	Opt_with() IOpt_withContext
	Createdb_opt_list() ICreatedb_opt_listContext

	// IsCreatedbstmtContext differentiates from other interfaces.
	IsCreatedbstmtContext()
}

type CreatedbstmtContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyCreatedbstmtContext() *CreatedbstmtContext {
	var p = new(CreatedbstmtContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_createdbstmt
	return p
}

func InitEmptyCreatedbstmtContext(p *CreatedbstmtContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_createdbstmt
}

func (*CreatedbstmtContext) IsCreatedbstmtContext() {}

func NewCreatedbstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CreatedbstmtContext {
	var p = new(CreatedbstmtContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_createdbstmt

	return p
}

func (s *CreatedbstmtContext) GetParser() antlr.Parser { return s.parser }

func (s *CreatedbstmtContext) CREATE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCREATE, 0)
}

func (s *CreatedbstmtContext) DATABASE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserDATABASE, 0)
}

func (s *CreatedbstmtContext) Name() INameContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(INameContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(INameContext)
}

func (s *CreatedbstmtContext) Opt_with() IOpt_withContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOpt_withContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOpt_withContext)
}

func (s *CreatedbstmtContext) Createdb_opt_list() ICreatedb_opt_listContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ICreatedb_opt_listContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ICreatedb_opt_listContext)
}

func (s *CreatedbstmtContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *CreatedbstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *CreatedbstmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterCreatedbstmt(s)
	}
}

func (s *CreatedbstmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitCreatedbstmt(s)
	}
}

func (s *CreatedbstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitCreatedbstmt(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Createdbstmt() (localctx ICreatedbstmtContext) {
	localctx = NewCreatedbstmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 804, PostgreSQLParserRULE_createdbstmt)
	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(7219)
		p.Match(PostgreSQLParserCREATE)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(7220)
		p.Match(PostgreSQLParserDATABASE)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(7221)
		p.Name()
	}
	{
		p.SetState(7222)
		p.Opt_with()
	}
	{
		p.SetState(7223)
		p.Createdb_opt_list()
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// ICreatedb_opt_listContext is an interface to support dynamic dispatch.
type ICreatedb_opt_listContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Createdb_opt_items() ICreatedb_opt_itemsContext

	// IsCreatedb_opt_listContext differentiates from other interfaces.
	IsCreatedb_opt_listContext()
}

type Createdb_opt_listContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyCreatedb_opt_listContext() *Createdb_opt_listContext {
	var p = new(Createdb_opt_listContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_createdb_opt_list
	return p
}

func InitEmptyCreatedb_opt_listContext(p *Createdb_opt_listContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_createdb_opt_list
}

func (*Createdb_opt_listContext) IsCreatedb_opt_listContext() {}

func NewCreatedb_opt_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Createdb_opt_listContext {
	var p = new(Createdb_opt_listContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_createdb_opt_list

	return p
}

func (s *Createdb_opt_listContext) GetParser() antlr.Parser { return s.parser }

func (s *Createdb_opt_listContext) Createdb_opt_items() ICreatedb_opt_itemsContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ICreatedb_opt_itemsContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ICreatedb_opt_itemsContext)
}

func (s *Createdb_opt_listContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Createdb_opt_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Createdb_opt_listContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterCreatedb_opt_list(s)
	}
}

func (s *Createdb_opt_listContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitCreatedb_opt_list(s)
	}
}

func (s *Createdb_opt_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitCreatedb_opt_list(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Createdb_opt_list() (localctx ICreatedb_opt_listContext) {
	localctx = NewCreatedb_opt_listContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 806, PostgreSQLParserRULE_createdb_opt_list)
	p.SetState(7227)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 345, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(7225)
			p.Createdb_opt_items()
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)

	case antlr.ATNInvalidAltNumber:
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// ICreatedb_opt_itemsContext is an interface to support dynamic dispatch.
type ICreatedb_opt_itemsContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	AllCreatedb_opt_item() []ICreatedb_opt_itemContext
	Createdb_opt_item(i int) ICreatedb_opt_itemContext

	// IsCreatedb_opt_itemsContext differentiates from other interfaces.
	IsCreatedb_opt_itemsContext()
}

type Createdb_opt_itemsContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyCreatedb_opt_itemsContext() *Createdb_opt_itemsContext {
	var p = new(Createdb_opt_itemsContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_createdb_opt_items
	return p
}

func InitEmptyCreatedb_opt_itemsContext(p *Createdb_opt_itemsContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_createdb_opt_items
}

func (*Createdb_opt_itemsContext) IsCreatedb_opt_itemsContext() {}

func NewCreatedb_opt_itemsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Createdb_opt_itemsContext {
	var p = new(Createdb_opt_itemsContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_createdb_opt_items

	return p
}

func (s *Createdb_opt_itemsContext) GetParser() antlr.Parser { return s.parser }

func (s *Createdb_opt_itemsContext) AllCreatedb_opt_item() []ICreatedb_opt_itemContext {
	children := s.GetChildren()
	len := 0
	for _, ctx := range children {
		if _, ok := ctx.(ICreatedb_opt_itemContext); ok {
			len++
		}
	}

	tst := make([]ICreatedb_opt_itemContext, len)
	i := 0
	for _, ctx := range children {
		if t, ok := ctx.(ICreatedb_opt_itemContext); ok {
			tst[i] = t.(ICreatedb_opt_itemContext)
			i++
		}
	}

	return tst
}

func (s *Createdb_opt_itemsContext) Createdb_opt_item(i int) ICreatedb_opt_itemContext {
	var t antlr.RuleContext
	j := 0
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ICreatedb_opt_itemContext); ok {
			if j == i {
				t = ctx.(antlr.RuleContext)
				break
			}
			j++
		}
	}

	if t == nil {
		return nil
	}

	return t.(ICreatedb_opt_itemContext)
}

func (s *Createdb_opt_itemsContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Createdb_opt_itemsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Createdb_opt_itemsContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterCreatedb_opt_items(s)
	}
}

func (s *Createdb_opt_itemsContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitCreatedb_opt_items(s)
	}
}

func (s *Createdb_opt_itemsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitCreatedb_opt_items(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Createdb_opt_items() (localctx ICreatedb_opt_itemsContext) {
	localctx = NewCreatedb_opt_itemsContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 808, PostgreSQLParserRULE_createdb_opt_items)
	var _alt int

	p.EnterOuterAlt(localctx, 1)
	p.SetState(7230)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}
	_alt = 1
	for ok := true; ok; ok = _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
		switch _alt {
		case 1:
			{
				p.SetState(7229)
				p.Createdb_opt_item()
			}

		default:
			p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
			goto errorExit
		}

		p.SetState(7232)
		p.GetErrorHandler().Sync(p)
		_alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 346, p.GetParserRuleContext())
		if p.HasError() {
			goto errorExit
		}
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// ICreatedb_opt_itemContext is an interface to support dynamic dispatch.
type ICreatedb_opt_itemContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Createdb_opt_name() ICreatedb_opt_nameContext
	Opt_equal() IOpt_equalContext
	Signediconst() ISignediconstContext
	Opt_boolean_or_string() IOpt_boolean_or_stringContext
	DEFAULT() antlr.TerminalNode

	// IsCreatedb_opt_itemContext differentiates from other interfaces.
	IsCreatedb_opt_itemContext()
}

type Createdb_opt_itemContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyCreatedb_opt_itemContext() *Createdb_opt_itemContext {
	var p = new(Createdb_opt_itemContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_createdb_opt_item
	return p
}

func InitEmptyCreatedb_opt_itemContext(p *Createdb_opt_itemContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_createdb_opt_item
}

func (*Createdb_opt_itemContext) IsCreatedb_opt_itemContext() {}

func NewCreatedb_opt_itemContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Createdb_opt_itemContext {
	var p = new(Createdb_opt_itemContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_createdb_opt_item

	return p
}

func (s *Createdb_opt_itemContext) GetParser() antlr.Parser { return s.parser }

func (s *Createdb_opt_itemContext) Createdb_opt_name() ICreatedb_opt_nameContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ICreatedb_opt_nameContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ICreatedb_opt_nameContext)
}

func (s *Createdb_opt_itemContext) Opt_equal() IOpt_equalContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOpt_equalContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOpt_equalContext)
}

func (s *Createdb_opt_itemContext) Signediconst() ISignediconstContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ISignediconstContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ISignediconstContext)
}

func (s *Createdb_opt_itemContext) Opt_boolean_or_string() IOpt_boolean_or_stringContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOpt_boolean_or_stringContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOpt_boolean_or_stringContext)
}

func (s *Createdb_opt_itemContext) DEFAULT() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserDEFAULT, 0)
}

func (s *Createdb_opt_itemContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Createdb_opt_itemContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Createdb_opt_itemContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterCreatedb_opt_item(s)
	}
}

func (s *Createdb_opt_itemContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitCreatedb_opt_item(s)
	}
}

func (s *Createdb_opt_itemContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitCreatedb_opt_item(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Createdb_opt_item() (localctx ICreatedb_opt_itemContext) {
	localctx = NewCreatedb_opt_itemContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 810, PostgreSQLParserRULE_createdb_opt_item)
	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(7234)
		p.Createdb_opt_name()
	}
	{
		p.SetState(7235)
		p.Opt_equal()
	}
	p.SetState(7239)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 347, p.GetParserRuleContext()) {
	case 1:
		{
			p.SetState(7236)
			p.Signediconst()
		}

	case 2:
		{
			p.SetState(7237)
			p.Opt_boolean_or_string()
		}

	case 3:
		{
			p.SetState(7238)
			p.Match(PostgreSQLParserDEFAULT)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case antlr.ATNInvalidAltNumber:
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// ICreatedb_opt_nameContext is an interface to support dynamic dispatch.
type ICreatedb_opt_nameContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Identifier() IIdentifierContext
	CONNECTION() antlr.TerminalNode
	LIMIT() antlr.TerminalNode
	ENCODING() antlr.TerminalNode
	LOCATION() antlr.TerminalNode
	OWNER() antlr.TerminalNode
	TABLESPACE() antlr.TerminalNode
	TEMPLATE() antlr.TerminalNode

	// IsCreatedb_opt_nameContext differentiates from other interfaces.
	IsCreatedb_opt_nameContext()
}

type Createdb_opt_nameContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyCreatedb_opt_nameContext() *Createdb_opt_nameContext {
	var p = new(Createdb_opt_nameContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_createdb_opt_name
	return p
}

func InitEmptyCreatedb_opt_nameContext(p *Createdb_opt_nameContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_createdb_opt_name
}

func (*Createdb_opt_nameContext) IsCreatedb_opt_nameContext() {}

func NewCreatedb_opt_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Createdb_opt_nameContext {
	var p = new(Createdb_opt_nameContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_createdb_opt_name

	return p
}

func (s *Createdb_opt_nameContext) GetParser() antlr.Parser { return s.parser }

func (s *Createdb_opt_nameContext) Identifier() IIdentifierContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IIdentifierContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IIdentifierContext)
}

func (s *Createdb_opt_nameContext) CONNECTION() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCONNECTION, 0)
}

func (s *Createdb_opt_nameContext) LIMIT() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserLIMIT, 0)
}

func (s *Createdb_opt_nameContext) ENCODING() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserENCODING, 0)
}

func (s *Createdb_opt_nameContext) LOCATION() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserLOCATION, 0)
}

func (s *Createdb_opt_nameContext) OWNER() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserOWNER, 0)
}

func (s *Createdb_opt_nameContext) TABLESPACE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserTABLESPACE, 0)
}

func (s *Createdb_opt_nameContext) TEMPLATE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserTEMPLATE, 0)
}

func (s *Createdb_opt_nameContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Createdb_opt_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Createdb_opt_nameContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterCreatedb_opt_name(s)
	}
}

func (s *Createdb_opt_nameContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitCreatedb_opt_name(s)
	}
}

func (s *Createdb_opt_nameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitCreatedb_opt_name(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Createdb_opt_name() (localctx ICreatedb_opt_nameContext) {
	localctx = NewCreatedb_opt_nameContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 812, PostgreSQLParserRULE_createdb_opt_name)
	p.SetState(7249)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetTokenStream().LA(1) {
	case PostgreSQLParserAND, PostgreSQLParserARRAY, PostgreSQLParserCOLLATE, PostgreSQLParserCOLUMN, PostgreSQLParserCONSTRAINT, PostgreSQLParserDEFAULT, PostgreSQLParserDO, PostgreSQLParserFETCH, PostgreSQLParserTABLE, PostgreSQLParserIS, PostgreSQLParserOUTER_P, PostgreSQLParserABSOLUTE_P, PostgreSQLParserBACKWARD, PostgreSQLParserCHAIN, PostgreSQLParserCLOSE, PostgreSQLParserCOMMIT, PostgreSQLParserCONTINUE_P, PostgreSQLParserCURSOR, PostgreSQLParserFIRST_P, PostgreSQLParserFORWARD, PostgreSQLParserINSERT, PostgreSQLParserLAST_P, PostgreSQLParserMOVE, PostgreSQLParserNEXT, PostgreSQLParserNO, PostgreSQLParserOPTION, PostgreSQLParserPRIOR, PostgreSQLParserRELATIVE_P, PostgreSQLParserRESET, PostgreSQLParserROLLBACK, PostgreSQLParserSCHEMA, PostgreSQLParserSCROLL, PostgreSQLParserSET, PostgreSQLParserTYPE_P, PostgreSQLParserCALL, PostgreSQLParserCURRENT_P, PostgreSQLParserROWTYPE, PostgreSQLParserDUMP, PostgreSQLParserPRINT_STRICT_PARAMS, PostgreSQLParserVARIABLE_CONFLICT, PostgreSQLParserERROR, PostgreSQLParserUSE_VARIABLE, PostgreSQLParserUSE_COLUMN, PostgreSQLParserALIAS, PostgreSQLParserCONSTANT, PostgreSQLParserPERFORM, PostgreSQLParserGET, PostgreSQLParserDIAGNOSTICS, PostgreSQLParserSTACKED, PostgreSQLParserELSIF, PostgreSQLParserSLICE, PostgreSQLParserEXIT, PostgreSQLParserRETURN, PostgreSQLParserQUERY, PostgreSQLParserRAISE, PostgreSQLParserSQLSTATE, PostgreSQLParserDEBUG, PostgreSQLParserINFO, PostgreSQLParserNOTICE, PostgreSQLParserWARNING, PostgreSQLParserEXCEPTION, PostgreSQLParserASSERT, PostgreSQLParserOPEN, PostgreSQLParserIdentifier, PostgreSQLParserQuotedIdentifier, PostgreSQLParserUnicodeQuotedIdentifier, PostgreSQLParserPLSQLVARIABLENAME, PostgreSQLParserPLSQLIDENTIFIER:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(7241)
			p.Identifier()
		}

	case PostgreSQLParserCONNECTION:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(7242)
			p.Match(PostgreSQLParserCONNECTION)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(7243)
			p.Match(PostgreSQLParserLIMIT)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case PostgreSQLParserENCODING:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(7244)
			p.Match(PostgreSQLParserENCODING)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case PostgreSQLParserLOCATION:
		p.EnterOuterAlt(localctx, 4)
		{
			p.SetState(7245)
			p.Match(PostgreSQLParserLOCATION)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case PostgreSQLParserOWNER:
		p.EnterOuterAlt(localctx, 5)
		{
			p.SetState(7246)
			p.Match(PostgreSQLParserOWNER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case PostgreSQLParserTABLESPACE:
		p.EnterOuterAlt(localctx, 6)
		{
			p.SetState(7247)
			p.Match(PostgreSQLParserTABLESPACE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case PostgreSQLParserTEMPLATE:
		p.EnterOuterAlt(localctx, 7)
		{
			p.SetState(7248)
			p.Match(PostgreSQLParserTEMPLATE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	default:
		p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IOpt_equalContext is an interface to support dynamic dispatch.
type IOpt_equalContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	EQUAL() antlr.TerminalNode

	// IsOpt_equalContext differentiates from other interfaces.
	IsOpt_equalContext()
}

type Opt_equalContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyOpt_equalContext() *Opt_equalContext {
	var p = new(Opt_equalContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opt_equal
	return p
}

func InitEmptyOpt_equalContext(p *Opt_equalContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opt_equal
}

func (*Opt_equalContext) IsOpt_equalContext() {}

func NewOpt_equalContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_equalContext {
	var p = new(Opt_equalContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_opt_equal

	return p
}

func (s *Opt_equalContext) GetParser() antlr.Parser { return s.parser }

func (s *Opt_equalContext) EQUAL() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserEQUAL, 0)
}

func (s *Opt_equalContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Opt_equalContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Opt_equalContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterOpt_equal(s)
	}
}

func (s *Opt_equalContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitOpt_equal(s)
	}
}

func (s *Opt_equalContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitOpt_equal(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Opt_equal() (localctx IOpt_equalContext) {
	localctx = NewOpt_equalContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 814, PostgreSQLParserRULE_opt_equal)
	p.SetState(7253)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetTokenStream().LA(1) {
	case PostgreSQLParserEQUAL:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(7251)
			p.Match(PostgreSQLParserEQUAL)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case PostgreSQLParserPLUS, PostgreSQLParserMINUS, PostgreSQLParserAND, PostgreSQLParserARRAY, PostgreSQLParserCOLLATE, PostgreSQLParserCOLUMN, PostgreSQLParserCONSTRAINT, PostgreSQLParserDEFAULT, PostgreSQLParserDO, PostgreSQLParserFALSE_P, PostgreSQLParserFETCH, PostgreSQLParserON, PostgreSQLParserTABLE, PostgreSQLParserTRUE_P, PostgreSQLParserAUTHORIZATION, PostgreSQLParserBINARY, PostgreSQLParserCOLLATION, PostgreSQLParserCONCURRENTLY, PostgreSQLParserCROSS, PostgreSQLParserCURRENT_SCHEMA, PostgreSQLParserFREEZE, PostgreSQLParserFULL, PostgreSQLParserILIKE, PostgreSQLParserINNER_P, PostgreSQLParserIS, PostgreSQLParserISNULL, PostgreSQLParserJOIN, PostgreSQLParserLIKE, PostgreSQLParserNATURAL, PostgreSQLParserNOTNULL, PostgreSQLParserOUTER_P, PostgreSQLParserOVER, PostgreSQLParserOVERLAPS, PostgreSQLParserSIMILAR, PostgreSQLParserVERBOSE, PostgreSQLParserABORT_P, PostgreSQLParserABSOLUTE_P, PostgreSQLParserACCESS, PostgreSQLParserACTION, PostgreSQLParserADD_P, PostgreSQLParserADMIN, PostgreSQLParserAFTER, PostgreSQLParserAGGREGATE, PostgreSQLParserALSO, PostgreSQLParserALTER, PostgreSQLParserALWAYS, PostgreSQLParserASSERTION, PostgreSQLParserASSIGNMENT, PostgreSQLParserAT, PostgreSQLParserATTRIBUTE, PostgreSQLParserBACKWARD, PostgreSQLParserBEFORE, PostgreSQLParserBEGIN_P, PostgreSQLParserBY, PostgreSQLParserCACHE, PostgreSQLParserCALLED, PostgreSQLParserCASCADE, PostgreSQLParserCASCADED, PostgreSQLParserCATALOG, PostgreSQLParserCHAIN, PostgreSQLParserCHARACTERISTICS, PostgreSQLParserCHECKPOINT, PostgreSQLParserCLASS, PostgreSQLParserCLOSE, PostgreSQLParserCLUSTER, PostgreSQLParserCOMMENT, PostgreSQLParserCOMMENTS, PostgreSQLParserCOMMIT, PostgreSQLParserCOMMITTED, PostgreSQLParserCONFIGURATION, PostgreSQLParserCONNECTION, PostgreSQLParserCONSTRAINTS, PostgreSQLParserCONTENT_P, PostgreSQLParserCONTINUE_P, PostgreSQLParserCONVERSION_P, PostgreSQLParserCOPY, PostgreSQLParserCOST, PostgreSQLParserCSV, PostgreSQLParserCURSOR, PostgreSQLParserCYCLE, PostgreSQLParserDATA_P, PostgreSQLParserDATABASE, PostgreSQLParserDAY_P, PostgreSQLParserDEALLOCATE, PostgreSQLParserDECLARE, PostgreSQLParserDEFAULTS, PostgreSQLParserDEFERRED, PostgreSQLParserDEFINER, PostgreSQLParserDELETE_P, PostgreSQLParserDELIMITER, PostgreSQLParserDELIMITERS, PostgreSQLParserDICTIONARY, PostgreSQLParserDISABLE_P, PostgreSQLParserDISCARD, PostgreSQLParserDOCUMENT_P, PostgreSQLParserDOMAIN_P, PostgreSQLParserDOUBLE_P, PostgreSQLParserDROP, PostgreSQLParserEACH, PostgreSQLParserENABLE_P, PostgreSQLParserENCODING, PostgreSQLParserENCRYPTED, PostgreSQLParserENUM_P, PostgreSQLParserESCAPE, PostgreSQLParserEVENT, PostgreSQLParserEXCLUDE, PostgreSQLParserEXCLUDING, PostgreSQLParserEXCLUSIVE, PostgreSQLParserEXECUTE, PostgreSQLParserEXPLAIN, PostgreSQLParserEXTENSION, PostgreSQLParserEXTERNAL, PostgreSQLParserFAMILY, PostgreSQLParserFIRST_P, PostgreSQLParserFOLLOWING, PostgreSQLParserFORCE, PostgreSQLParserFORWARD, PostgreSQLParserFUNCTION, PostgreSQLParserFUNCTIONS, PostgreSQLParserGLOBAL, PostgreSQLParserGRANTED, PostgreSQLParserHANDLER, PostgreSQLParserHEADER_P, PostgreSQLParserHOLD, PostgreSQLParserHOUR_P, PostgreSQLParserIDENTITY_P, PostgreSQLParserIF_P, PostgreSQLParserIMMEDIATE, PostgreSQLParserIMMUTABLE, PostgreSQLParserIMPLICIT_P, PostgreSQLParserINCLUDING, PostgreSQLParserINCREMENT, PostgreSQLParserINDEX, PostgreSQLParserINDEXES, PostgreSQLParserINHERIT, PostgreSQLParserINHERITS, PostgreSQLParserINLINE_P, PostgreSQLParserINSENSITIVE, PostgreSQLParserINSERT, PostgreSQLParserINSTEAD, PostgreSQLParserINVOKER, PostgreSQLParserISOLATION, PostgreSQLParserKEY, PostgreSQLParserLABEL, PostgreSQLParserLANGUAGE, PostgreSQLParserLARGE_P, PostgreSQLParserLAST_P, PostgreSQLParserLEAKPROOF, PostgreSQLParserLEVEL, PostgreSQLParserLISTEN, PostgreSQLParserLOAD, PostgreSQLParserLOCAL, PostgreSQLParserLOCATION, PostgreSQLParserLOCK_P, PostgreSQLParserMAPPING, PostgreSQLParserMATCH, PostgreSQLParserMATERIALIZED, PostgreSQLParserMAXVALUE, PostgreSQLParserMINUTE_P, PostgreSQLParserMINVALUE, PostgreSQLParserMODE, PostgreSQLParserMONTH_P, PostgreSQLParserMOVE, PostgreSQLParserNAME_P, PostgreSQLParserNAMES, PostgreSQLParserNEXT, PostgreSQLParserNO, PostgreSQLParserNOTHING, PostgreSQLParserNOTIFY, PostgreSQLParserNOWAIT, PostgreSQLParserNULLS_P, PostgreSQLParserOBJECT_P, PostgreSQLParserOF, PostgreSQLParserOFF, PostgreSQLParserOIDS, PostgreSQLParserOPERATOR, PostgreSQLParserOPTION, PostgreSQLParserOPTIONS, PostgreSQLParserOWNED, PostgreSQLParserOWNER, PostgreSQLParserPARSER, PostgreSQLParserPARTIAL, PostgreSQLParserPARTITION, PostgreSQLParserPASSING, PostgreSQLParserPASSWORD, PostgreSQLParserPLANS, PostgreSQLParserPRECEDING, PostgreSQLParserPREPARE, PostgreSQLParserPREPARED, PostgreSQLParserPRESERVE, PostgreSQLParserPRIOR, PostgreSQLParserPRIVILEGES, PostgreSQLParserPROCEDURAL, PostgreSQLParserPROCEDURE, PostgreSQLParserPROGRAM, PostgreSQLParserQUOTE, PostgreSQLParserRANGE, PostgreSQLParserREAD, PostgreSQLParserREASSIGN, PostgreSQLParserRECHECK, PostgreSQLParserRECURSIVE, PostgreSQLParserREF, PostgreSQLParserREFRESH, PostgreSQLParserREINDEX, PostgreSQLParserRELATIVE_P, PostgreSQLParserRELEASE, PostgreSQLParserRENAME, PostgreSQLParserREPEATABLE, PostgreSQLParserREPLACE, PostgreSQLParserREPLICA, PostgreSQLParserRESET, PostgreSQLParserRESTART, PostgreSQLParserRESTRICT, PostgreSQLParserRETURNS, PostgreSQLParserREVOKE, PostgreSQLParserROLE, PostgreSQLParserROLLBACK, PostgreSQLParserROWS, PostgreSQLParserRULE, PostgreSQLParserSAVEPOINT, PostgreSQLParserSCHEMA, PostgreSQLParserSCROLL, PostgreSQLParserSEARCH, PostgreSQLParserSECOND_P, PostgreSQLParserSECURITY, PostgreSQLParserSEQUENCE, PostgreSQLParserSEQUENCES, PostgreSQLParserSERIALIZABLE, PostgreSQLParserSERVER, PostgreSQLParserSESSION, PostgreSQLParserSET, PostgreSQLParserSHARE, PostgreSQLParserSHOW, PostgreSQLParserSIMPLE, PostgreSQLParserSNAPSHOT, PostgreSQLParserSTABLE, PostgreSQLParserSTANDALONE_P, PostgreSQLParserSTART, PostgreSQLParserSTATEMENT, PostgreSQLParserSTATISTICS, PostgreSQLParserSTDIN, PostgreSQLParserSTDOUT, PostgreSQLParserSTORAGE, PostgreSQLParserSTRICT_P, PostgreSQLParserSTRIP_P, PostgreSQLParserSYSID, PostgreSQLParserSYSTEM_P, PostgreSQLParserTABLES, PostgreSQLParserTABLESPACE, PostgreSQLParserTEMP, PostgreSQLParserTEMPLATE, PostgreSQLParserTEMPORARY, PostgreSQLParserTEXT_P, PostgreSQLParserTRANSACTION, PostgreSQLParserTRIGGER, PostgreSQLParserTRUNCATE, PostgreSQLParserTRUSTED, PostgreSQLParserTYPE_P, PostgreSQLParserTYPES_P, PostgreSQLParserUNBOUNDED, PostgreSQLParserUNCOMMITTED, PostgreSQLParserUNENCRYPTED, PostgreSQLParserUNKNOWN, PostgreSQLParserUNLISTEN, PostgreSQLParserUNLOGGED, PostgreSQLParserUNTIL, PostgreSQLParserUPDATE, PostgreSQLParserVACUUM, PostgreSQLParserVALID, PostgreSQLParserVALIDATE, PostgreSQLParserVALIDATOR, PostgreSQLParserVARYING, PostgreSQLParserVERSION_P, PostgreSQLParserVIEW, PostgreSQLParserVOLATILE, PostgreSQLParserWHITESPACE_P, PostgreSQLParserWITHOUT, PostgreSQLParserWORK, PostgreSQLParserWRAPPER, PostgreSQLParserWRITE, PostgreSQLParserXML_P, PostgreSQLParserYEAR_P, PostgreSQLParserYES_P, PostgreSQLParserZONE, PostgreSQLParserBETWEEN, PostgreSQLParserBIGINT, PostgreSQLParserBIT, PostgreSQLParserBOOLEAN_P, PostgreSQLParserCHAR_P, PostgreSQLParserCHARACTER, PostgreSQLParserCOALESCE, PostgreSQLParserDEC, PostgreSQLParserDECIMAL_P, PostgreSQLParserEXISTS, PostgreSQLParserEXTRACT, PostgreSQLParserFLOAT_P, PostgreSQLParserGREATEST, PostgreSQLParserINOUT, PostgreSQLParserINT_P, PostgreSQLParserINTEGER, PostgreSQLParserINTERVAL, PostgreSQLParserLEAST, PostgreSQLParserNATIONAL, PostgreSQLParserNCHAR, PostgreSQLParserNONE, PostgreSQLParserNULLIF, PostgreSQLParserNUMERIC, PostgreSQLParserOVERLAY, PostgreSQLParserPOSITION, PostgreSQLParserPRECISION, PostgreSQLParserREAL, PostgreSQLParserROW, PostgreSQLParserSETOF, PostgreSQLParserSMALLINT, PostgreSQLParserSUBSTRING, PostgreSQLParserTIME, PostgreSQLParserTIMESTAMP, PostgreSQLParserTREAT, PostgreSQLParserTRIM, PostgreSQLParserVALUES, PostgreSQLParserVARCHAR, PostgreSQLParserXMLATTRIBUTES, PostgreSQLParserXMLCOMMENT, PostgreSQLParserXMLAGG, PostgreSQLParserXML_IS_WELL_FORMED, PostgreSQLParserXML_IS_WELL_FORMED_DOCUMENT, PostgreSQLParserXML_IS_WELL_FORMED_CONTENT, PostgreSQLParserXPATH, PostgreSQLParserXPATH_EXISTS, PostgreSQLParserXMLCONCAT, PostgreSQLParserXMLELEMENT, PostgreSQLParserXMLEXISTS, PostgreSQLParserXMLFOREST, PostgreSQLParserXMLPARSE, PostgreSQLParserXMLPI, PostgreSQLParserXMLROOT, PostgreSQLParserXMLSERIALIZE, PostgreSQLParserCALL, PostgreSQLParserCURRENT_P, PostgreSQLParserATTACH, PostgreSQLParserDETACH, PostgreSQLParserEXPRESSION, PostgreSQLParserGENERATED, PostgreSQLParserLOGGED, PostgreSQLParserSTORED, PostgreSQLParserINCLUDE, PostgreSQLParserROUTINE, PostgreSQLParserTRANSFORM, PostgreSQLParserIMPORT_P, PostgreSQLParserPOLICY, PostgreSQLParserMETHOD, PostgreSQLParserREFERENCING, PostgreSQLParserNEW, PostgreSQLParserOLD, PostgreSQLParserVALUE_P, PostgreSQLParserSUBSCRIPTION, PostgreSQLParserPUBLICATION, PostgreSQLParserOUT_P, PostgreSQLParserROUTINES, PostgreSQLParserSCHEMAS, PostgreSQLParserPROCEDURES, PostgreSQLParserINPUT_P, PostgreSQLParserSUPPORT, PostgreSQLParserPARALLEL, PostgreSQLParserSQL_P, PostgreSQLParserDEPENDS, PostgreSQLParserOVERRIDING, PostgreSQLParserCONFLICT, PostgreSQLParserSKIP_P, PostgreSQLParserLOCKED, PostgreSQLParserTIES, PostgreSQLParserROLLUP, PostgreSQLParserCUBE, PostgreSQLParserGROUPING, PostgreSQLParserSETS, PostgreSQLParserTABLESAMPLE, PostgreSQLParserORDINALITY, PostgreSQLParserXMLTABLE, PostgreSQLParserCOLUMNS, PostgreSQLParserXMLNAMESPACES, PostgreSQLParserROWTYPE, PostgreSQLParserNORMALIZED, PostgreSQLParserWITHIN, PostgreSQLParserFILTER, PostgreSQLParserGROUPS, PostgreSQLParserOTHERS, PostgreSQLParserNFC, PostgreSQLParserNFD, PostgreSQLParserNFKC, PostgreSQLParserNFKD, PostgreSQLParserUESCAPE, PostgreSQLParserVIEWS, PostgreSQLParserNORMALIZE, PostgreSQLParserDUMP, PostgreSQLParserPRINT_STRICT_PARAMS, PostgreSQLParserVARIABLE_CONFLICT, PostgreSQLParserERROR, PostgreSQLParserUSE_VARIABLE, PostgreSQLParserUSE_COLUMN, PostgreSQLParserALIAS, PostgreSQLParserCONSTANT, PostgreSQLParserPERFORM, PostgreSQLParserGET, PostgreSQLParserDIAGNOSTICS, PostgreSQLParserSTACKED, PostgreSQLParserELSIF, PostgreSQLParserREVERSE, PostgreSQLParserSLICE, PostgreSQLParserEXIT, PostgreSQLParserRETURN, PostgreSQLParserQUERY, PostgreSQLParserRAISE, PostgreSQLParserSQLSTATE, PostgreSQLParserDEBUG, PostgreSQLParserLOG, PostgreSQLParserINFO, PostgreSQLParserNOTICE, PostgreSQLParserWARNING, PostgreSQLParserEXCEPTION, PostgreSQLParserASSERT, PostgreSQLParserOPEN, PostgreSQLParserABS, PostgreSQLParserCBRT, PostgreSQLParserCEIL, PostgreSQLParserCEILING, PostgreSQLParserDEGREES, PostgreSQLParserDIV, PostgreSQLParserEXP, PostgreSQLParserFACTORIAL, PostgreSQLParserFLOOR, PostgreSQLParserGCD, PostgreSQLParserLCM, PostgreSQLParserLN, PostgreSQLParserLOG10, PostgreSQLParserMIN_SCALE, PostgreSQLParserMOD, PostgreSQLParserPI, PostgreSQLParserPOWER, PostgreSQLParserRADIANS, PostgreSQLParserROUND, PostgreSQLParserSCALE, PostgreSQLParserSIGN, PostgreSQLParserSQRT, PostgreSQLParserTRIM_SCALE, PostgreSQLParserTRUNC, PostgreSQLParserWIDTH_BUCKET, PostgreSQLParserRANDOM, PostgreSQLParserSETSEED, PostgreSQLParserACOS, PostgreSQLParserACOSD, PostgreSQLParserASIN, PostgreSQLParserASIND, PostgreSQLParserATAN, PostgreSQLParserATAND, PostgreSQLParserATAN2, PostgreSQLParserATAN2D, PostgreSQLParserCOS, PostgreSQLParserCOSD, PostgreSQLParserCOT, PostgreSQLParserCOTD, PostgreSQLParserSIN, PostgreSQLParserSIND, PostgreSQLParserTAN, PostgreSQLParserTAND, PostgreSQLParserSINH, PostgreSQLParserCOSH, PostgreSQLParserTANH, PostgreSQLParserASINH, PostgreSQLParserACOSH, PostgreSQLParserATANH, PostgreSQLParserBIT_LENGTH, PostgreSQLParserCHAR_LENGTH, PostgreSQLParserCHARACTER_LENGTH, PostgreSQLParserLOWER, PostgreSQLParserOCTET_LENGTH, PostgreSQLParserUPPER, PostgreSQLParserASCII, PostgreSQLParserBTRIM, PostgreSQLParserCHR, PostgreSQLParserCONCAT, PostgreSQLParserCONCAT_WS, PostgreSQLParserFORMAT, PostgreSQLParserINITCAP, PostgreSQLParserLENGTH, PostgreSQLParserLPAD, PostgreSQLParserLTRIM, PostgreSQLParserMD5, PostgreSQLParserPARSE_IDENT, PostgreSQLParserPG_CLIENT_ENCODING, PostgreSQLParserQUOTE_IDENT, PostgreSQLParserQUOTE_LITERAL, PostgreSQLParserQUOTE_NULLABLE, PostgreSQLParserREGEXP_COUNT, PostgreSQLParserREGEXP_INSTR, PostgreSQLParserREGEXP_LIKE, PostgreSQLParserREGEXP_MATCH, PostgreSQLParserREGEXP_MATCHES, PostgreSQLParserREGEXP_REPLACE, PostgreSQLParserREGEXP_SPLIT_TO_ARRAY, PostgreSQLParserREGEXP_SPLIT_TO_TABLE, PostgreSQLParserREGEXP_SUBSTR, PostgreSQLParserREPEAT, PostgreSQLParserRPAD, PostgreSQLParserRTRIM, PostgreSQLParserSPLIT_PART, PostgreSQLParserSTARTS_WITH, PostgreSQLParserSTRING_TO_ARRAY, PostgreSQLParserSTRING_TO_TABLE, PostgreSQLParserSTRPOS, PostgreSQLParserSUBSTR, PostgreSQLParserTO_ASCII, PostgreSQLParserTO_HEX, PostgreSQLParserTRANSLATE, PostgreSQLParserUNISTR, PostgreSQLParserAGE, PostgreSQLParserCLOCK_TIMESTAMP, PostgreSQLParserDATE_BIN, PostgreSQLParserDATE_PART, PostgreSQLParserDATE_TRUNC, PostgreSQLParserISFINITE, PostgreSQLParserJUSTIFY_DAYS, PostgreSQLParserJUSTIFY_HOURS, PostgreSQLParserJUSTIFY_INTERVAL, PostgreSQLParserMAKE_DATE, PostgreSQLParserMAKE_INTERVAL, PostgreSQLParserMAKE_TIME, PostgreSQLParserMAKE_TIMESTAMP, PostgreSQLParserMAKE_TIMESTAMPTZ, PostgreSQLParserNOW, PostgreSQLParserSTATEMENT_TIMESTAMP, PostgreSQLParserTIMEOFDAY, PostgreSQLParserTRANSACTION_TIMESTAMP, PostgreSQLParserTO_TIMESTAMP, PostgreSQLParserTO_CHAR, PostgreSQLParserTO_DATE, PostgreSQLParserTO_NUMBER, PostgreSQLParserIdentifier, PostgreSQLParserQuotedIdentifier, PostgreSQLParserUnicodeQuotedIdentifier, PostgreSQLParserStringConstant, PostgreSQLParserUnicodeEscapeStringConstant, PostgreSQLParserBeginDollarStringConstant, PostgreSQLParserIntegral, PostgreSQLParserPLSQLVARIABLENAME, PostgreSQLParserPLSQLIDENTIFIER, PostgreSQLParserEscapeStringConstant:
		p.EnterOuterAlt(localctx, 2)

	default:
		p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IAlterdatabasestmtContext is an interface to support dynamic dispatch.
type IAlterdatabasestmtContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	ALTER() antlr.TerminalNode
	DATABASE() antlr.TerminalNode
	AllName() []INameContext
	Name(i int) INameContext
	WITH() antlr.TerminalNode
	Createdb_opt_list() ICreatedb_opt_listContext
	SET() antlr.TerminalNode
	TABLESPACE() antlr.TerminalNode

	// IsAlterdatabasestmtContext differentiates from other interfaces.
	IsAlterdatabasestmtContext()
}

type AlterdatabasestmtContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyAlterdatabasestmtContext() *AlterdatabasestmtContext {
	var p = new(AlterdatabasestmtContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_alterdatabasestmt
	return p
}

func InitEmptyAlterdatabasestmtContext(p *AlterdatabasestmtContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_alterdatabasestmt
}

func (*AlterdatabasestmtContext) IsAlterdatabasestmtContext() {}

func NewAlterdatabasestmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AlterdatabasestmtContext {
	var p = new(AlterdatabasestmtContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_alterdatabasestmt

	return p
}

func (s *AlterdatabasestmtContext) GetParser() antlr.Parser { return s.parser }

func (s *AlterdatabasestmtContext) ALTER() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserALTER, 0)
}

func (s *AlterdatabasestmtContext) DATABASE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserDATABASE, 0)
}

func (s *AlterdatabasestmtContext) AllName() []INameContext {
	children := s.GetChildren()
	len := 0
	for _, ctx := range children {
		if _, ok := ctx.(INameContext); ok {
			len++
		}
	}

	tst := make([]INameContext, len)
	i := 0
	for _, ctx := range children {
		if t, ok := ctx.(INameContext); ok {
			tst[i] = t.(INameContext)
			i++
		}
	}

	return tst
}

func (s *AlterdatabasestmtContext) Name(i int) INameContext {
	var t antlr.RuleContext
	j := 0
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(INameContext); ok {
			if j == i {
				t = ctx.(antlr.RuleContext)
				break
			}
			j++
		}
	}

	if t == nil {
		return nil
	}

	return t.(INameContext)
}

func (s *AlterdatabasestmtContext) WITH() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserWITH, 0)
}

func (s *AlterdatabasestmtContext) Createdb_opt_list() ICreatedb_opt_listContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ICreatedb_opt_listContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ICreatedb_opt_listContext)
}

func (s *AlterdatabasestmtContext) SET() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserSET, 0)
}

func (s *AlterdatabasestmtContext) TABLESPACE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserTABLESPACE, 0)
}

func (s *AlterdatabasestmtContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *AlterdatabasestmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *AlterdatabasestmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterAlterdatabasestmt(s)
	}
}

func (s *AlterdatabasestmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitAlterdatabasestmt(s)
	}
}

func (s *AlterdatabasestmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitAlterdatabasestmt(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Alterdatabasestmt() (localctx IAlterdatabasestmtContext) {
	localctx = NewAlterdatabasestmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 816, PostgreSQLParserRULE_alterdatabasestmt)
	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(7255)
		p.Match(PostgreSQLParserALTER)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(7256)
		p.Match(PostgreSQLParserDATABASE)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(7257)
		p.Name()
	}
	p.SetState(7264)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 350, p.GetParserRuleContext()) {
	case 1:
		{
			p.SetState(7258)
			p.Match(PostgreSQLParserWITH)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(7259)
			p.Createdb_opt_list()
		}

	case 2:
		{
			p.SetState(7260)
			p.Createdb_opt_list()
		}

	case 3:
		{
			p.SetState(7261)
			p.Match(PostgreSQLParserSET)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(7262)
			p.Match(PostgreSQLParserTABLESPACE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(7263)
			p.Name()
		}

	case antlr.ATNInvalidAltNumber:
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IAlterdatabasesetstmtContext is an interface to support dynamic dispatch.
type IAlterdatabasesetstmtContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	ALTER() antlr.TerminalNode
	DATABASE() antlr.TerminalNode
	Name() INameContext
	Setresetclause() ISetresetclauseContext

	// IsAlterdatabasesetstmtContext differentiates from other interfaces.
	IsAlterdatabasesetstmtContext()
}

type AlterdatabasesetstmtContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyAlterdatabasesetstmtContext() *AlterdatabasesetstmtContext {
	var p = new(AlterdatabasesetstmtContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_alterdatabasesetstmt
	return p
}

func InitEmptyAlterdatabasesetstmtContext(p *AlterdatabasesetstmtContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_alterdatabasesetstmt
}

func (*AlterdatabasesetstmtContext) IsAlterdatabasesetstmtContext() {}

func NewAlterdatabasesetstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AlterdatabasesetstmtContext {
	var p = new(AlterdatabasesetstmtContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_alterdatabasesetstmt

	return p
}

func (s *AlterdatabasesetstmtContext) GetParser() antlr.Parser { return s.parser }

func (s *AlterdatabasesetstmtContext) ALTER() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserALTER, 0)
}

func (s *AlterdatabasesetstmtContext) DATABASE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserDATABASE, 0)
}

func (s *AlterdatabasesetstmtContext) Name() INameContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(INameContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(INameContext)
}

func (s *AlterdatabasesetstmtContext) Setresetclause() ISetresetclauseContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ISetresetclauseContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ISetresetclauseContext)
}

func (s *AlterdatabasesetstmtContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *AlterdatabasesetstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *AlterdatabasesetstmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterAlterdatabasesetstmt(s)
	}
}

func (s *AlterdatabasesetstmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitAlterdatabasesetstmt(s)
	}
}

func (s *AlterdatabasesetstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitAlterdatabasesetstmt(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Alterdatabasesetstmt() (localctx IAlterdatabasesetstmtContext) {
	localctx = NewAlterdatabasesetstmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 818, PostgreSQLParserRULE_alterdatabasesetstmt)
	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(7266)
		p.Match(PostgreSQLParserALTER)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(7267)
		p.Match(PostgreSQLParserDATABASE)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(7268)
		p.Name()
	}
	{
		p.SetState(7269)
		p.Setresetclause()
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IDropdbstmtContext is an interface to support dynamic dispatch.
type IDropdbstmtContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	DROP() antlr.TerminalNode
	DATABASE() antlr.TerminalNode
	Name() INameContext
	IF_P() antlr.TerminalNode
	EXISTS() antlr.TerminalNode
	Opt_with() IOpt_withContext
	OPEN_PAREN() antlr.TerminalNode
	Drop_option_list() IDrop_option_listContext
	CLOSE_PAREN() antlr.TerminalNode

	// IsDropdbstmtContext differentiates from other interfaces.
	IsDropdbstmtContext()
}

type DropdbstmtContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyDropdbstmtContext() *DropdbstmtContext {
	var p = new(DropdbstmtContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_dropdbstmt
	return p
}

func InitEmptyDropdbstmtContext(p *DropdbstmtContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_dropdbstmt
}

func (*DropdbstmtContext) IsDropdbstmtContext() {}

func NewDropdbstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DropdbstmtContext {
	var p = new(DropdbstmtContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_dropdbstmt

	return p
}

func (s *DropdbstmtContext) GetParser() antlr.Parser { return s.parser }

func (s *DropdbstmtContext) DROP() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserDROP, 0)
}

func (s *DropdbstmtContext) DATABASE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserDATABASE, 0)
}

func (s *DropdbstmtContext) Name() INameContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(INameContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(INameContext)
}

func (s *DropdbstmtContext) IF_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserIF_P, 0)
}

func (s *DropdbstmtContext) EXISTS() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserEXISTS, 0)
}

func (s *DropdbstmtContext) Opt_with() IOpt_withContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOpt_withContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOpt_withContext)
}

func (s *DropdbstmtContext) OPEN_PAREN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserOPEN_PAREN, 0)
}

func (s *DropdbstmtContext) Drop_option_list() IDrop_option_listContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IDrop_option_listContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IDrop_option_listContext)
}

func (s *DropdbstmtContext) CLOSE_PAREN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCLOSE_PAREN, 0)
}

func (s *DropdbstmtContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *DropdbstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *DropdbstmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterDropdbstmt(s)
	}
}

func (s *DropdbstmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitDropdbstmt(s)
	}
}

func (s *DropdbstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitDropdbstmt(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Dropdbstmt() (localctx IDropdbstmtContext) {
	localctx = NewDropdbstmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 820, PostgreSQLParserRULE_dropdbstmt)
	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(7271)
		p.Match(PostgreSQLParserDROP)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(7272)
		p.Match(PostgreSQLParserDATABASE)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	p.SetState(7275)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 351, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(7273)
			p.Match(PostgreSQLParserIF_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(7274)
			p.Match(PostgreSQLParserEXISTS)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	} else if p.HasError() { // JIM
		goto errorExit
	}
	{
		p.SetState(7277)
		p.Name()
	}
	p.SetState(7283)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 352, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(7278)
			p.Opt_with()
		}
		{
			p.SetState(7279)
			p.Match(PostgreSQLParserOPEN_PAREN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(7280)
			p.Drop_option_list()
		}
		{
			p.SetState(7281)
			p.Match(PostgreSQLParserCLOSE_PAREN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	} else if p.HasError() { // JIM
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IDrop_option_listContext is an interface to support dynamic dispatch.
type IDrop_option_listContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	AllDrop_option() []IDrop_optionContext
	Drop_option(i int) IDrop_optionContext
	AllCOMMA() []antlr.TerminalNode
	COMMA(i int) antlr.TerminalNode

	// IsDrop_option_listContext differentiates from other interfaces.
	IsDrop_option_listContext()
}

type Drop_option_listContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyDrop_option_listContext() *Drop_option_listContext {
	var p = new(Drop_option_listContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_drop_option_list
	return p
}

func InitEmptyDrop_option_listContext(p *Drop_option_listContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_drop_option_list
}

func (*Drop_option_listContext) IsDrop_option_listContext() {}

func NewDrop_option_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_option_listContext {
	var p = new(Drop_option_listContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_drop_option_list

	return p
}

func (s *Drop_option_listContext) GetParser() antlr.Parser { return s.parser }

func (s *Drop_option_listContext) AllDrop_option() []IDrop_optionContext {
	children := s.GetChildren()
	len := 0
	for _, ctx := range children {
		if _, ok := ctx.(IDrop_optionContext); ok {
			len++
		}
	}

	tst := make([]IDrop_optionContext, len)
	i := 0
	for _, ctx := range children {
		if t, ok := ctx.(IDrop_optionContext); ok {
			tst[i] = t.(IDrop_optionContext)
			i++
		}
	}

	return tst
}

func (s *Drop_option_listContext) Drop_option(i int) IDrop_optionContext {
	var t antlr.RuleContext
	j := 0
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IDrop_optionContext); ok {
			if j == i {
				t = ctx.(antlr.RuleContext)
				break
			}
			j++
		}
	}

	if t == nil {
		return nil
	}

	return t.(IDrop_optionContext)
}

func (s *Drop_option_listContext) AllCOMMA() []antlr.TerminalNode {
	return s.GetTokens(PostgreSQLParserCOMMA)
}

func (s *Drop_option_listContext) COMMA(i int) antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCOMMA, i)
}

func (s *Drop_option_listContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Drop_option_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Drop_option_listContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterDrop_option_list(s)
	}
}

func (s *Drop_option_listContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitDrop_option_list(s)
	}
}

func (s *Drop_option_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitDrop_option_list(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Drop_option_list() (localctx IDrop_option_listContext) {
	localctx = NewDrop_option_listContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 822, PostgreSQLParserRULE_drop_option_list)
	var _la int

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(7285)
		p.Drop_option()
	}
	p.SetState(7290)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}
	_la = p.GetTokenStream().LA(1)

	for _la == PostgreSQLParserCOMMA {
		{
			p.SetState(7286)
			p.Match(PostgreSQLParserCOMMA)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(7287)
			p.Drop_option()
		}

		p.SetState(7292)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}
		_la = p.GetTokenStream().LA(1)
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IDrop_optionContext is an interface to support dynamic dispatch.
type IDrop_optionContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	FORCE() antlr.TerminalNode

	// IsDrop_optionContext differentiates from other interfaces.
	IsDrop_optionContext()
}

type Drop_optionContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyDrop_optionContext() *Drop_optionContext {
	var p = new(Drop_optionContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_drop_option
	return p
}

func InitEmptyDrop_optionContext(p *Drop_optionContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_drop_option
}

func (*Drop_optionContext) IsDrop_optionContext() {}

func NewDrop_optionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_optionContext {
	var p = new(Drop_optionContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_drop_option

	return p
}

func (s *Drop_optionContext) GetParser() antlr.Parser { return s.parser }

func (s *Drop_optionContext) FORCE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserFORCE, 0)
}

func (s *Drop_optionContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Drop_optionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Drop_optionContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterDrop_option(s)
	}
}

func (s *Drop_optionContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitDrop_option(s)
	}
}

func (s *Drop_optionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitDrop_option(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Drop_option() (localctx IDrop_optionContext) {
	localctx = NewDrop_optionContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 824, PostgreSQLParserRULE_drop_option)
	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(7293)
		p.Match(PostgreSQLParserFORCE)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IAltercollationstmtContext is an interface to support dynamic dispatch.
type IAltercollationstmtContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	ALTER() antlr.TerminalNode
	COLLATION() antlr.TerminalNode
	Any_name() IAny_nameContext
	REFRESH() antlr.TerminalNode
	VERSION_P() antlr.TerminalNode

	// IsAltercollationstmtContext differentiates from other interfaces.
	IsAltercollationstmtContext()
}

type AltercollationstmtContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyAltercollationstmtContext() *AltercollationstmtContext {
	var p = new(AltercollationstmtContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_altercollationstmt
	return p
}

func InitEmptyAltercollationstmtContext(p *AltercollationstmtContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_altercollationstmt
}

func (*AltercollationstmtContext) IsAltercollationstmtContext() {}

func NewAltercollationstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AltercollationstmtContext {
	var p = new(AltercollationstmtContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_altercollationstmt

	return p
}

func (s *AltercollationstmtContext) GetParser() antlr.Parser { return s.parser }

func (s *AltercollationstmtContext) ALTER() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserALTER, 0)
}

func (s *AltercollationstmtContext) COLLATION() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCOLLATION, 0)
}

func (s *AltercollationstmtContext) Any_name() IAny_nameContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IAny_nameContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IAny_nameContext)
}

func (s *AltercollationstmtContext) REFRESH() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserREFRESH, 0)
}

func (s *AltercollationstmtContext) VERSION_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserVERSION_P, 0)
}

func (s *AltercollationstmtContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *AltercollationstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *AltercollationstmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterAltercollationstmt(s)
	}
}

func (s *AltercollationstmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitAltercollationstmt(s)
	}
}

func (s *AltercollationstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitAltercollationstmt(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Altercollationstmt() (localctx IAltercollationstmtContext) {
	localctx = NewAltercollationstmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 826, PostgreSQLParserRULE_altercollationstmt)
	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(7295)
		p.Match(PostgreSQLParserALTER)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(7296)
		p.Match(PostgreSQLParserCOLLATION)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(7297)
		p.Any_name()
	}
	{
		p.SetState(7298)
		p.Match(PostgreSQLParserREFRESH)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(7299)
		p.Match(PostgreSQLParserVERSION_P)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IAltersystemstmtContext is an interface to support dynamic dispatch.
type IAltersystemstmtContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	ALTER() antlr.TerminalNode
	SYSTEM_P() antlr.TerminalNode
	Generic_set() IGeneric_setContext
	SET() antlr.TerminalNode
	RESET() antlr.TerminalNode

	// IsAltersystemstmtContext differentiates from other interfaces.
	IsAltersystemstmtContext()
}

type AltersystemstmtContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyAltersystemstmtContext() *AltersystemstmtContext {
	var p = new(AltersystemstmtContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_altersystemstmt
	return p
}

func InitEmptyAltersystemstmtContext(p *AltersystemstmtContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_altersystemstmt
}

func (*AltersystemstmtContext) IsAltersystemstmtContext() {}

func NewAltersystemstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AltersystemstmtContext {
	var p = new(AltersystemstmtContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_altersystemstmt

	return p
}

func (s *AltersystemstmtContext) GetParser() antlr.Parser { return s.parser }

func (s *AltersystemstmtContext) ALTER() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserALTER, 0)
}

func (s *AltersystemstmtContext) SYSTEM_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserSYSTEM_P, 0)
}

func (s *AltersystemstmtContext) Generic_set() IGeneric_setContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IGeneric_setContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IGeneric_setContext)
}

func (s *AltersystemstmtContext) SET() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserSET, 0)
}

func (s *AltersystemstmtContext) RESET() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserRESET, 0)
}

func (s *AltersystemstmtContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *AltersystemstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *AltersystemstmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterAltersystemstmt(s)
	}
}

func (s *AltersystemstmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitAltersystemstmt(s)
	}
}

func (s *AltersystemstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitAltersystemstmt(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Altersystemstmt() (localctx IAltersystemstmtContext) {
	localctx = NewAltersystemstmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 828, PostgreSQLParserRULE_altersystemstmt)
	var _la int

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(7301)
		p.Match(PostgreSQLParserALTER)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(7302)
		p.Match(PostgreSQLParserSYSTEM_P)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(7303)
		_la = p.GetTokenStream().LA(1)

		if !(_la == PostgreSQLParserRESET || _la == PostgreSQLParserSET) {
			p.GetErrorHandler().RecoverInline(p)
		} else {
			p.GetErrorHandler().ReportMatch(p)
			p.Consume()
		}
	}
	{
		p.SetState(7304)
		p.Generic_set()
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// ICreatedomainstmtContext is an interface to support dynamic dispatch.
type ICreatedomainstmtContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	CREATE() antlr.TerminalNode
	DOMAIN_P() antlr.TerminalNode
	Any_name() IAny_nameContext
	Opt_as() IOpt_asContext
	Typename() ITypenameContext
	Colquallist() IColquallistContext

	// IsCreatedomainstmtContext differentiates from other interfaces.
	IsCreatedomainstmtContext()
}

type CreatedomainstmtContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyCreatedomainstmtContext() *CreatedomainstmtContext {
	var p = new(CreatedomainstmtContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_createdomainstmt
	return p
}

func InitEmptyCreatedomainstmtContext(p *CreatedomainstmtContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_createdomainstmt
}

func (*CreatedomainstmtContext) IsCreatedomainstmtContext() {}

func NewCreatedomainstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CreatedomainstmtContext {
	var p = new(CreatedomainstmtContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_createdomainstmt

	return p
}

func (s *CreatedomainstmtContext) GetParser() antlr.Parser { return s.parser }

func (s *CreatedomainstmtContext) CREATE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCREATE, 0)
}

func (s *CreatedomainstmtContext) DOMAIN_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserDOMAIN_P, 0)
}

func (s *CreatedomainstmtContext) Any_name() IAny_nameContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IAny_nameContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IAny_nameContext)
}

func (s *CreatedomainstmtContext) Opt_as() IOpt_asContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOpt_asContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOpt_asContext)
}

func (s *CreatedomainstmtContext) Typename() ITypenameContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ITypenameContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ITypenameContext)
}

func (s *CreatedomainstmtContext) Colquallist() IColquallistContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IColquallistContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IColquallistContext)
}

func (s *CreatedomainstmtContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *CreatedomainstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *CreatedomainstmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterCreatedomainstmt(s)
	}
}

func (s *CreatedomainstmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitCreatedomainstmt(s)
	}
}

func (s *CreatedomainstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitCreatedomainstmt(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Createdomainstmt() (localctx ICreatedomainstmtContext) {
	localctx = NewCreatedomainstmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 830, PostgreSQLParserRULE_createdomainstmt)
	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(7306)
		p.Match(PostgreSQLParserCREATE)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(7307)
		p.Match(PostgreSQLParserDOMAIN_P)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(7308)
		p.Any_name()
	}
	{
		p.SetState(7309)
		p.Opt_as()
	}
	{
		p.SetState(7310)
		p.Typename()
	}
	{
		p.SetState(7311)
		p.Colquallist()
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IAlterdomainstmtContext is an interface to support dynamic dispatch.
type IAlterdomainstmtContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	ALTER() antlr.TerminalNode
	DOMAIN_P() antlr.TerminalNode
	Any_name() IAny_nameContext
	Alter_column_default() IAlter_column_defaultContext
	DROP() antlr.TerminalNode
	NOT() antlr.TerminalNode
	NULL_P() antlr.TerminalNode
	SET() antlr.TerminalNode
	ADD_P() antlr.TerminalNode
	Tableconstraint() ITableconstraintContext
	CONSTRAINT() antlr.TerminalNode
	Name() INameContext
	Opt_drop_behavior() IOpt_drop_behaviorContext
	VALIDATE() antlr.TerminalNode
	IF_P() antlr.TerminalNode
	EXISTS() antlr.TerminalNode

	// IsAlterdomainstmtContext differentiates from other interfaces.
	IsAlterdomainstmtContext()
}

type AlterdomainstmtContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyAlterdomainstmtContext() *AlterdomainstmtContext {
	var p = new(AlterdomainstmtContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_alterdomainstmt
	return p
}

func InitEmptyAlterdomainstmtContext(p *AlterdomainstmtContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_alterdomainstmt
}

func (*AlterdomainstmtContext) IsAlterdomainstmtContext() {}

func NewAlterdomainstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AlterdomainstmtContext {
	var p = new(AlterdomainstmtContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_alterdomainstmt

	return p
}

func (s *AlterdomainstmtContext) GetParser() antlr.Parser { return s.parser }

func (s *AlterdomainstmtContext) ALTER() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserALTER, 0)
}

func (s *AlterdomainstmtContext) DOMAIN_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserDOMAIN_P, 0)
}

func (s *AlterdomainstmtContext) Any_name() IAny_nameContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IAny_nameContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IAny_nameContext)
}

func (s *AlterdomainstmtContext) Alter_column_default() IAlter_column_defaultContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IAlter_column_defaultContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IAlter_column_defaultContext)
}

func (s *AlterdomainstmtContext) DROP() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserDROP, 0)
}

func (s *AlterdomainstmtContext) NOT() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserNOT, 0)
}

func (s *AlterdomainstmtContext) NULL_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserNULL_P, 0)
}

func (s *AlterdomainstmtContext) SET() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserSET, 0)
}

func (s *AlterdomainstmtContext) ADD_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserADD_P, 0)
}

func (s *AlterdomainstmtContext) Tableconstraint() ITableconstraintContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ITableconstraintContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ITableconstraintContext)
}

func (s *AlterdomainstmtContext) CONSTRAINT() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCONSTRAINT, 0)
}

func (s *AlterdomainstmtContext) Name() INameContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(INameContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(INameContext)
}

func (s *AlterdomainstmtContext) Opt_drop_behavior() IOpt_drop_behaviorContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOpt_drop_behaviorContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOpt_drop_behaviorContext)
}

func (s *AlterdomainstmtContext) VALIDATE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserVALIDATE, 0)
}

func (s *AlterdomainstmtContext) IF_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserIF_P, 0)
}

func (s *AlterdomainstmtContext) EXISTS() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserEXISTS, 0)
}

func (s *AlterdomainstmtContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *AlterdomainstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *AlterdomainstmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterAlterdomainstmt(s)
	}
}

func (s *AlterdomainstmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitAlterdomainstmt(s)
	}
}

func (s *AlterdomainstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitAlterdomainstmt(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Alterdomainstmt() (localctx IAlterdomainstmtContext) {
	localctx = NewAlterdomainstmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 832, PostgreSQLParserRULE_alterdomainstmt)
	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(7313)
		p.Match(PostgreSQLParserALTER)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(7314)
		p.Match(PostgreSQLParserDOMAIN_P)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(7315)
		p.Any_name()
	}
	p.SetState(7337)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 355, p.GetParserRuleContext()) {
	case 1:
		{
			p.SetState(7316)
			p.Alter_column_default()
		}

	case 2:
		{
			p.SetState(7317)
			p.Match(PostgreSQLParserDROP)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(7318)
			p.Match(PostgreSQLParserNOT)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(7319)
			p.Match(PostgreSQLParserNULL_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 3:
		{
			p.SetState(7320)
			p.Match(PostgreSQLParserSET)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(7321)
			p.Match(PostgreSQLParserNOT)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(7322)
			p.Match(PostgreSQLParserNULL_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 4:
		{
			p.SetState(7323)
			p.Match(PostgreSQLParserADD_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(7324)
			p.Tableconstraint()
		}

	case 5:
		{
			p.SetState(7325)
			p.Match(PostgreSQLParserDROP)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(7326)
			p.Match(PostgreSQLParserCONSTRAINT)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		p.SetState(7329)
		p.GetErrorHandler().Sync(p)

		if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 354, p.GetParserRuleContext()) == 1 {
			{
				p.SetState(7327)
				p.Match(PostgreSQLParserIF_P)
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}
			{
				p.SetState(7328)
				p.Match(PostgreSQLParserEXISTS)
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}

		} else if p.HasError() { // JIM
			goto errorExit
		}
		{
			p.SetState(7331)
			p.Name()
		}
		{
			p.SetState(7332)
			p.Opt_drop_behavior()
		}

	case 6:
		{
			p.SetState(7334)
			p.Match(PostgreSQLParserVALIDATE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(7335)
			p.Match(PostgreSQLParserCONSTRAINT)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(7336)
			p.Name()
		}

	case antlr.ATNInvalidAltNumber:
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IOpt_asContext is an interface to support dynamic dispatch.
type IOpt_asContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	AS() antlr.TerminalNode

	// IsOpt_asContext differentiates from other interfaces.
	IsOpt_asContext()
}

type Opt_asContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyOpt_asContext() *Opt_asContext {
	var p = new(Opt_asContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opt_as
	return p
}

func InitEmptyOpt_asContext(p *Opt_asContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opt_as
}

func (*Opt_asContext) IsOpt_asContext() {}

func NewOpt_asContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_asContext {
	var p = new(Opt_asContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_opt_as

	return p
}

func (s *Opt_asContext) GetParser() antlr.Parser { return s.parser }

func (s *Opt_asContext) AS() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserAS, 0)
}

func (s *Opt_asContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Opt_asContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Opt_asContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterOpt_as(s)
	}
}

func (s *Opt_asContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitOpt_as(s)
	}
}

func (s *Opt_asContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitOpt_as(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Opt_as() (localctx IOpt_asContext) {
	localctx = NewOpt_asContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 834, PostgreSQLParserRULE_opt_as)
	p.SetState(7341)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetTokenStream().LA(1) {
	case PostgreSQLParserAS:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(7339)
			p.Match(PostgreSQLParserAS)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case PostgreSQLParserAND, PostgreSQLParserARRAY, PostgreSQLParserCOLLATE, PostgreSQLParserCOLUMN, PostgreSQLParserCONSTRAINT, PostgreSQLParserDEFAULT, PostgreSQLParserDO, PostgreSQLParserFETCH, PostgreSQLParserTABLE, PostgreSQLParserAUTHORIZATION, PostgreSQLParserBINARY, PostgreSQLParserCOLLATION, PostgreSQLParserCONCURRENTLY, PostgreSQLParserCROSS, PostgreSQLParserCURRENT_SCHEMA, PostgreSQLParserFREEZE, PostgreSQLParserFULL, PostgreSQLParserILIKE, PostgreSQLParserINNER_P, PostgreSQLParserIS, PostgreSQLParserISNULL, PostgreSQLParserJOIN, PostgreSQLParserLEFT, PostgreSQLParserLIKE, PostgreSQLParserNATURAL, PostgreSQLParserNOTNULL, PostgreSQLParserOUTER_P, PostgreSQLParserOVER, PostgreSQLParserOVERLAPS, PostgreSQLParserRIGHT, PostgreSQLParserSIMILAR, PostgreSQLParserVERBOSE, PostgreSQLParserABORT_P, PostgreSQLParserABSOLUTE_P, PostgreSQLParserACCESS, PostgreSQLParserACTION, PostgreSQLParserADD_P, PostgreSQLParserADMIN, PostgreSQLParserAFTER, PostgreSQLParserAGGREGATE, PostgreSQLParserALSO, PostgreSQLParserALTER, PostgreSQLParserALWAYS, PostgreSQLParserASSERTION, PostgreSQLParserASSIGNMENT, PostgreSQLParserAT, PostgreSQLParserATTRIBUTE, PostgreSQLParserBACKWARD, PostgreSQLParserBEFORE, PostgreSQLParserBEGIN_P, PostgreSQLParserBY, PostgreSQLParserCACHE, PostgreSQLParserCALLED, PostgreSQLParserCASCADE, PostgreSQLParserCASCADED, PostgreSQLParserCATALOG, PostgreSQLParserCHAIN, PostgreSQLParserCHARACTERISTICS, PostgreSQLParserCHECKPOINT, PostgreSQLParserCLASS, PostgreSQLParserCLOSE, PostgreSQLParserCLUSTER, PostgreSQLParserCOMMENT, PostgreSQLParserCOMMENTS, PostgreSQLParserCOMMIT, PostgreSQLParserCOMMITTED, PostgreSQLParserCONFIGURATION, PostgreSQLParserCONNECTION, PostgreSQLParserCONSTRAINTS, PostgreSQLParserCONTENT_P, PostgreSQLParserCONTINUE_P, PostgreSQLParserCONVERSION_P, PostgreSQLParserCOPY, PostgreSQLParserCOST, PostgreSQLParserCSV, PostgreSQLParserCURSOR, PostgreSQLParserCYCLE, PostgreSQLParserDATA_P, PostgreSQLParserDATABASE, PostgreSQLParserDAY_P, PostgreSQLParserDEALLOCATE, PostgreSQLParserDECLARE, PostgreSQLParserDEFAULTS, PostgreSQLParserDEFERRED, PostgreSQLParserDEFINER, PostgreSQLParserDELETE_P, PostgreSQLParserDELIMITER, PostgreSQLParserDELIMITERS, PostgreSQLParserDICTIONARY, PostgreSQLParserDISABLE_P, PostgreSQLParserDISCARD, PostgreSQLParserDOCUMENT_P, PostgreSQLParserDOMAIN_P, PostgreSQLParserDOUBLE_P, PostgreSQLParserDROP, PostgreSQLParserEACH, PostgreSQLParserENABLE_P, PostgreSQLParserENCODING, PostgreSQLParserENCRYPTED, PostgreSQLParserENUM_P, PostgreSQLParserESCAPE, PostgreSQLParserEVENT, PostgreSQLParserEXCLUDE, PostgreSQLParserEXCLUDING, PostgreSQLParserEXCLUSIVE, PostgreSQLParserEXECUTE, PostgreSQLParserEXPLAIN, PostgreSQLParserEXTENSION, PostgreSQLParserEXTERNAL, PostgreSQLParserFAMILY, PostgreSQLParserFIRST_P, PostgreSQLParserFOLLOWING, PostgreSQLParserFORCE, PostgreSQLParserFORWARD, PostgreSQLParserFUNCTION, PostgreSQLParserFUNCTIONS, PostgreSQLParserGLOBAL, PostgreSQLParserGRANTED, PostgreSQLParserHANDLER, PostgreSQLParserHEADER_P, PostgreSQLParserHOLD, PostgreSQLParserHOUR_P, PostgreSQLParserIDENTITY_P, PostgreSQLParserIF_P, PostgreSQLParserIMMEDIATE, PostgreSQLParserIMMUTABLE, PostgreSQLParserIMPLICIT_P, PostgreSQLParserINCLUDING, PostgreSQLParserINCREMENT, PostgreSQLParserINDEX, PostgreSQLParserINDEXES, PostgreSQLParserINHERIT, PostgreSQLParserINHERITS, PostgreSQLParserINLINE_P, PostgreSQLParserINSENSITIVE, PostgreSQLParserINSERT, PostgreSQLParserINSTEAD, PostgreSQLParserINVOKER, PostgreSQLParserISOLATION, PostgreSQLParserKEY, PostgreSQLParserLABEL, PostgreSQLParserLANGUAGE, PostgreSQLParserLARGE_P, PostgreSQLParserLAST_P, PostgreSQLParserLEAKPROOF, PostgreSQLParserLEVEL, PostgreSQLParserLISTEN, PostgreSQLParserLOAD, PostgreSQLParserLOCAL, PostgreSQLParserLOCATION, PostgreSQLParserLOCK_P, PostgreSQLParserMAPPING, PostgreSQLParserMATCH, PostgreSQLParserMATERIALIZED, PostgreSQLParserMAXVALUE, PostgreSQLParserMINUTE_P, PostgreSQLParserMINVALUE, PostgreSQLParserMODE, PostgreSQLParserMONTH_P, PostgreSQLParserMOVE, PostgreSQLParserNAME_P, PostgreSQLParserNAMES, PostgreSQLParserNEXT, PostgreSQLParserNO, PostgreSQLParserNOTHING, PostgreSQLParserNOTIFY, PostgreSQLParserNOWAIT, PostgreSQLParserNULLS_P, PostgreSQLParserOBJECT_P, PostgreSQLParserOF, PostgreSQLParserOFF, PostgreSQLParserOIDS, PostgreSQLParserOPERATOR, PostgreSQLParserOPTION, PostgreSQLParserOPTIONS, PostgreSQLParserOWNED, PostgreSQLParserOWNER, PostgreSQLParserPARSER, PostgreSQLParserPARTIAL, PostgreSQLParserPARTITION, PostgreSQLParserPASSING, PostgreSQLParserPASSWORD, PostgreSQLParserPLANS, PostgreSQLParserPRECEDING, PostgreSQLParserPREPARE, PostgreSQLParserPREPARED, PostgreSQLParserPRESERVE, PostgreSQLParserPRIOR, PostgreSQLParserPRIVILEGES, PostgreSQLParserPROCEDURAL, PostgreSQLParserPROCEDURE, PostgreSQLParserPROGRAM, PostgreSQLParserQUOTE, PostgreSQLParserRANGE, PostgreSQLParserREAD, PostgreSQLParserREASSIGN, PostgreSQLParserRECHECK, PostgreSQLParserRECURSIVE, PostgreSQLParserREF, PostgreSQLParserREFRESH, PostgreSQLParserREINDEX, PostgreSQLParserRELATIVE_P, PostgreSQLParserRELEASE, PostgreSQLParserRENAME, PostgreSQLParserREPEATABLE, PostgreSQLParserREPLACE, PostgreSQLParserREPLICA, PostgreSQLParserRESET, PostgreSQLParserRESTART, PostgreSQLParserRESTRICT, PostgreSQLParserRETURNS, PostgreSQLParserREVOKE, PostgreSQLParserROLE, PostgreSQLParserROLLBACK, PostgreSQLParserROWS, PostgreSQLParserRULE, PostgreSQLParserSAVEPOINT, PostgreSQLParserSCHEMA, PostgreSQLParserSCROLL, PostgreSQLParserSEARCH, PostgreSQLParserSECOND_P, PostgreSQLParserSECURITY, PostgreSQLParserSEQUENCE, PostgreSQLParserSEQUENCES, PostgreSQLParserSERIALIZABLE, PostgreSQLParserSERVER, PostgreSQLParserSESSION, PostgreSQLParserSET, PostgreSQLParserSHARE, PostgreSQLParserSHOW, PostgreSQLParserSIMPLE, PostgreSQLParserSNAPSHOT, PostgreSQLParserSTABLE, PostgreSQLParserSTANDALONE_P, PostgreSQLParserSTART, PostgreSQLParserSTATEMENT, PostgreSQLParserSTATISTICS, PostgreSQLParserSTDIN, PostgreSQLParserSTDOUT, PostgreSQLParserSTORAGE, PostgreSQLParserSTRICT_P, PostgreSQLParserSTRIP_P, PostgreSQLParserSYSID, PostgreSQLParserSYSTEM_P, PostgreSQLParserTABLES, PostgreSQLParserTABLESPACE, PostgreSQLParserTEMP, PostgreSQLParserTEMPLATE, PostgreSQLParserTEMPORARY, PostgreSQLParserTEXT_P, PostgreSQLParserTRANSACTION, PostgreSQLParserTRIGGER, PostgreSQLParserTRUNCATE, PostgreSQLParserTRUSTED, PostgreSQLParserTYPE_P, PostgreSQLParserTYPES_P, PostgreSQLParserUNBOUNDED, PostgreSQLParserUNCOMMITTED, PostgreSQLParserUNENCRYPTED, PostgreSQLParserUNKNOWN, PostgreSQLParserUNLISTEN, PostgreSQLParserUNLOGGED, PostgreSQLParserUNTIL, PostgreSQLParserUPDATE, PostgreSQLParserVACUUM, PostgreSQLParserVALID, PostgreSQLParserVALIDATE, PostgreSQLParserVALIDATOR, PostgreSQLParserVARYING, PostgreSQLParserVERSION_P, PostgreSQLParserVIEW, PostgreSQLParserVOLATILE, PostgreSQLParserWHITESPACE_P, PostgreSQLParserWITHOUT, PostgreSQLParserWORK, PostgreSQLParserWRAPPER, PostgreSQLParserWRITE, PostgreSQLParserXML_P, PostgreSQLParserYEAR_P, PostgreSQLParserYES_P, PostgreSQLParserZONE, PostgreSQLParserBETWEEN, PostgreSQLParserBIGINT, PostgreSQLParserBIT, PostgreSQLParserBOOLEAN_P, PostgreSQLParserCHAR_P, PostgreSQLParserCHARACTER, PostgreSQLParserCOALESCE, PostgreSQLParserDEC, PostgreSQLParserDECIMAL_P, PostgreSQLParserEXISTS, PostgreSQLParserEXTRACT, PostgreSQLParserFLOAT_P, PostgreSQLParserGREATEST, PostgreSQLParserINOUT, PostgreSQLParserINT_P, PostgreSQLParserINTEGER, PostgreSQLParserINTERVAL, PostgreSQLParserLEAST, PostgreSQLParserNATIONAL, PostgreSQLParserNCHAR, PostgreSQLParserNONE, PostgreSQLParserNULLIF, PostgreSQLParserNUMERIC, PostgreSQLParserOVERLAY, PostgreSQLParserPOSITION, PostgreSQLParserPRECISION, PostgreSQLParserREAL, PostgreSQLParserROW, PostgreSQLParserSETOF, PostgreSQLParserSMALLINT, PostgreSQLParserSUBSTRING, PostgreSQLParserTIME, PostgreSQLParserTIMESTAMP, PostgreSQLParserTREAT, PostgreSQLParserTRIM, PostgreSQLParserVALUES, PostgreSQLParserVARCHAR, PostgreSQLParserXMLATTRIBUTES, PostgreSQLParserXMLCOMMENT, PostgreSQLParserXMLAGG, PostgreSQLParserXML_IS_WELL_FORMED, PostgreSQLParserXML_IS_WELL_FORMED_DOCUMENT, PostgreSQLParserXML_IS_WELL_FORMED_CONTENT, PostgreSQLParserXPATH, PostgreSQLParserXPATH_EXISTS, PostgreSQLParserXMLCONCAT, PostgreSQLParserXMLELEMENT, PostgreSQLParserXMLEXISTS, PostgreSQLParserXMLFOREST, PostgreSQLParserXMLPARSE, PostgreSQLParserXMLPI, PostgreSQLParserXMLROOT, PostgreSQLParserXMLSERIALIZE, PostgreSQLParserCALL, PostgreSQLParserCURRENT_P, PostgreSQLParserATTACH, PostgreSQLParserDETACH, PostgreSQLParserEXPRESSION, PostgreSQLParserGENERATED, PostgreSQLParserLOGGED, PostgreSQLParserSTORED, PostgreSQLParserINCLUDE, PostgreSQLParserROUTINE, PostgreSQLParserTRANSFORM, PostgreSQLParserIMPORT_P, PostgreSQLParserPOLICY, PostgreSQLParserMETHOD, PostgreSQLParserREFERENCING, PostgreSQLParserNEW, PostgreSQLParserOLD, PostgreSQLParserVALUE_P, PostgreSQLParserSUBSCRIPTION, PostgreSQLParserPUBLICATION, PostgreSQLParserOUT_P, PostgreSQLParserROUTINES, PostgreSQLParserSCHEMAS, PostgreSQLParserPROCEDURES, PostgreSQLParserINPUT_P, PostgreSQLParserSUPPORT, PostgreSQLParserPARALLEL, PostgreSQLParserSQL_P, PostgreSQLParserDEPENDS, PostgreSQLParserOVERRIDING, PostgreSQLParserCONFLICT, PostgreSQLParserSKIP_P, PostgreSQLParserLOCKED, PostgreSQLParserTIES, PostgreSQLParserROLLUP, PostgreSQLParserCUBE, PostgreSQLParserGROUPING, PostgreSQLParserSETS, PostgreSQLParserTABLESAMPLE, PostgreSQLParserORDINALITY, PostgreSQLParserXMLTABLE, PostgreSQLParserCOLUMNS, PostgreSQLParserXMLNAMESPACES, PostgreSQLParserROWTYPE, PostgreSQLParserNORMALIZED, PostgreSQLParserWITHIN, PostgreSQLParserFILTER, PostgreSQLParserGROUPS, PostgreSQLParserOTHERS, PostgreSQLParserNFC, PostgreSQLParserNFD, PostgreSQLParserNFKC, PostgreSQLParserNFKD, PostgreSQLParserUESCAPE, PostgreSQLParserVIEWS, PostgreSQLParserNORMALIZE, PostgreSQLParserDUMP, PostgreSQLParserPRINT_STRICT_PARAMS, PostgreSQLParserVARIABLE_CONFLICT, PostgreSQLParserERROR, PostgreSQLParserUSE_VARIABLE, PostgreSQLParserUSE_COLUMN, PostgreSQLParserALIAS, PostgreSQLParserCONSTANT, PostgreSQLParserPERFORM, PostgreSQLParserGET, PostgreSQLParserDIAGNOSTICS, PostgreSQLParserSTACKED, PostgreSQLParserELSIF, PostgreSQLParserREVERSE, PostgreSQLParserSLICE, PostgreSQLParserEXIT, PostgreSQLParserRETURN, PostgreSQLParserQUERY, PostgreSQLParserRAISE, PostgreSQLParserSQLSTATE, PostgreSQLParserDEBUG, PostgreSQLParserLOG, PostgreSQLParserINFO, PostgreSQLParserNOTICE, PostgreSQLParserWARNING, PostgreSQLParserEXCEPTION, PostgreSQLParserASSERT, PostgreSQLParserOPEN, PostgreSQLParserABS, PostgreSQLParserCBRT, PostgreSQLParserCEIL, PostgreSQLParserCEILING, PostgreSQLParserDEGREES, PostgreSQLParserDIV, PostgreSQLParserEXP, PostgreSQLParserFACTORIAL, PostgreSQLParserFLOOR, PostgreSQLParserGCD, PostgreSQLParserLCM, PostgreSQLParserLN, PostgreSQLParserLOG10, PostgreSQLParserMIN_SCALE, PostgreSQLParserMOD, PostgreSQLParserPI, PostgreSQLParserPOWER, PostgreSQLParserRADIANS, PostgreSQLParserROUND, PostgreSQLParserSCALE, PostgreSQLParserSIGN, PostgreSQLParserSQRT, PostgreSQLParserTRIM_SCALE, PostgreSQLParserTRUNC, PostgreSQLParserWIDTH_BUCKET, PostgreSQLParserRANDOM, PostgreSQLParserSETSEED, PostgreSQLParserACOS, PostgreSQLParserACOSD, PostgreSQLParserASIN, PostgreSQLParserASIND, PostgreSQLParserATAN, PostgreSQLParserATAND, PostgreSQLParserATAN2, PostgreSQLParserATAN2D, PostgreSQLParserCOS, PostgreSQLParserCOSD, PostgreSQLParserCOT, PostgreSQLParserCOTD, PostgreSQLParserSIN, PostgreSQLParserSIND, PostgreSQLParserTAN, PostgreSQLParserTAND, PostgreSQLParserSINH, PostgreSQLParserCOSH, PostgreSQLParserTANH, PostgreSQLParserASINH, PostgreSQLParserACOSH, PostgreSQLParserATANH, PostgreSQLParserBIT_LENGTH, PostgreSQLParserCHAR_LENGTH, PostgreSQLParserCHARACTER_LENGTH, PostgreSQLParserLOWER, PostgreSQLParserOCTET_LENGTH, PostgreSQLParserUPPER, PostgreSQLParserASCII, PostgreSQLParserBTRIM, PostgreSQLParserCHR, PostgreSQLParserCONCAT, PostgreSQLParserCONCAT_WS, PostgreSQLParserFORMAT, PostgreSQLParserINITCAP, PostgreSQLParserLENGTH, PostgreSQLParserLPAD, PostgreSQLParserLTRIM, PostgreSQLParserMD5, PostgreSQLParserPARSE_IDENT, PostgreSQLParserPG_CLIENT_ENCODING, PostgreSQLParserQUOTE_IDENT, PostgreSQLParserQUOTE_LITERAL, PostgreSQLParserQUOTE_NULLABLE, PostgreSQLParserREGEXP_COUNT, PostgreSQLParserREGEXP_INSTR, PostgreSQLParserREGEXP_LIKE, PostgreSQLParserREGEXP_MATCH, PostgreSQLParserREGEXP_MATCHES, PostgreSQLParserREGEXP_REPLACE, PostgreSQLParserREGEXP_SPLIT_TO_ARRAY, PostgreSQLParserREGEXP_SPLIT_TO_TABLE, PostgreSQLParserREGEXP_SUBSTR, PostgreSQLParserREPEAT, PostgreSQLParserRPAD, PostgreSQLParserRTRIM, PostgreSQLParserSPLIT_PART, PostgreSQLParserSTARTS_WITH, PostgreSQLParserSTRING_TO_ARRAY, PostgreSQLParserSTRING_TO_TABLE, PostgreSQLParserSTRPOS, PostgreSQLParserSUBSTR, PostgreSQLParserTO_ASCII, PostgreSQLParserTO_HEX, PostgreSQLParserTRANSLATE, PostgreSQLParserUNISTR, PostgreSQLParserAGE, PostgreSQLParserCLOCK_TIMESTAMP, PostgreSQLParserDATE_BIN, PostgreSQLParserDATE_PART, PostgreSQLParserDATE_TRUNC, PostgreSQLParserISFINITE, PostgreSQLParserJUSTIFY_DAYS, PostgreSQLParserJUSTIFY_HOURS, PostgreSQLParserJUSTIFY_INTERVAL, PostgreSQLParserMAKE_DATE, PostgreSQLParserMAKE_INTERVAL, PostgreSQLParserMAKE_TIME, PostgreSQLParserMAKE_TIMESTAMP, PostgreSQLParserMAKE_TIMESTAMPTZ, PostgreSQLParserNOW, PostgreSQLParserSTATEMENT_TIMESTAMP, PostgreSQLParserTIMEOFDAY, PostgreSQLParserTRANSACTION_TIMESTAMP, PostgreSQLParserTO_TIMESTAMP, PostgreSQLParserTO_CHAR, PostgreSQLParserTO_DATE, PostgreSQLParserTO_NUMBER, PostgreSQLParserIdentifier, PostgreSQLParserQuotedIdentifier, PostgreSQLParserUnicodeQuotedIdentifier, PostgreSQLParserStringConstant, PostgreSQLParserUnicodeEscapeStringConstant, PostgreSQLParserBeginDollarStringConstant, PostgreSQLParserPLSQLVARIABLENAME, PostgreSQLParserPLSQLIDENTIFIER, PostgreSQLParserEscapeStringConstant:
		p.EnterOuterAlt(localctx, 2)

	default:
		p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IAltertsdictionarystmtContext is an interface to support dynamic dispatch.
type IAltertsdictionarystmtContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	ALTER() antlr.TerminalNode
	TEXT_P() antlr.TerminalNode
	SEARCH() antlr.TerminalNode
	DICTIONARY() antlr.TerminalNode
	Any_name() IAny_nameContext
	Definition() IDefinitionContext

	// IsAltertsdictionarystmtContext differentiates from other interfaces.
	IsAltertsdictionarystmtContext()
}

type AltertsdictionarystmtContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyAltertsdictionarystmtContext() *AltertsdictionarystmtContext {
	var p = new(AltertsdictionarystmtContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_altertsdictionarystmt
	return p
}

func InitEmptyAltertsdictionarystmtContext(p *AltertsdictionarystmtContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_altertsdictionarystmt
}

func (*AltertsdictionarystmtContext) IsAltertsdictionarystmtContext() {}

func NewAltertsdictionarystmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AltertsdictionarystmtContext {
	var p = new(AltertsdictionarystmtContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_altertsdictionarystmt

	return p
}

func (s *AltertsdictionarystmtContext) GetParser() antlr.Parser { return s.parser }

func (s *AltertsdictionarystmtContext) ALTER() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserALTER, 0)
}

func (s *AltertsdictionarystmtContext) TEXT_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserTEXT_P, 0)
}

func (s *AltertsdictionarystmtContext) SEARCH() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserSEARCH, 0)
}

func (s *AltertsdictionarystmtContext) DICTIONARY() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserDICTIONARY, 0)
}

func (s *AltertsdictionarystmtContext) Any_name() IAny_nameContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IAny_nameContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IAny_nameContext)
}

func (s *AltertsdictionarystmtContext) Definition() IDefinitionContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IDefinitionContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IDefinitionContext)
}

func (s *AltertsdictionarystmtContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *AltertsdictionarystmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *AltertsdictionarystmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterAltertsdictionarystmt(s)
	}
}

func (s *AltertsdictionarystmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitAltertsdictionarystmt(s)
	}
}

func (s *AltertsdictionarystmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitAltertsdictionarystmt(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Altertsdictionarystmt() (localctx IAltertsdictionarystmtContext) {
	localctx = NewAltertsdictionarystmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 836, PostgreSQLParserRULE_altertsdictionarystmt)
	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(7343)
		p.Match(PostgreSQLParserALTER)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(7344)
		p.Match(PostgreSQLParserTEXT_P)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(7345)
		p.Match(PostgreSQLParserSEARCH)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(7346)
		p.Match(PostgreSQLParserDICTIONARY)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(7347)
		p.Any_name()
	}
	{
		p.SetState(7348)
		p.Definition()
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IAltertsconfigurationstmtContext is an interface to support dynamic dispatch.
type IAltertsconfigurationstmtContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	AllALTER() []antlr.TerminalNode
	ALTER(i int) antlr.TerminalNode
	TEXT_P() antlr.TerminalNode
	SEARCH() antlr.TerminalNode
	CONFIGURATION() antlr.TerminalNode
	AllAny_name() []IAny_nameContext
	Any_name(i int) IAny_nameContext
	ADD_P() antlr.TerminalNode
	MAPPING() antlr.TerminalNode
	FOR() antlr.TerminalNode
	Name_list() IName_listContext
	Any_with() IAny_withContext
	Any_name_list() IAny_name_listContext
	REPLACE() antlr.TerminalNode
	DROP() antlr.TerminalNode
	IF_P() antlr.TerminalNode
	EXISTS() antlr.TerminalNode

	// IsAltertsconfigurationstmtContext differentiates from other interfaces.
	IsAltertsconfigurationstmtContext()
}

type AltertsconfigurationstmtContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyAltertsconfigurationstmtContext() *AltertsconfigurationstmtContext {
	var p = new(AltertsconfigurationstmtContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_altertsconfigurationstmt
	return p
}

func InitEmptyAltertsconfigurationstmtContext(p *AltertsconfigurationstmtContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_altertsconfigurationstmt
}

func (*AltertsconfigurationstmtContext) IsAltertsconfigurationstmtContext() {}

func NewAltertsconfigurationstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AltertsconfigurationstmtContext {
	var p = new(AltertsconfigurationstmtContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_altertsconfigurationstmt

	return p
}

func (s *AltertsconfigurationstmtContext) GetParser() antlr.Parser { return s.parser }

func (s *AltertsconfigurationstmtContext) AllALTER() []antlr.TerminalNode {
	return s.GetTokens(PostgreSQLParserALTER)
}

func (s *AltertsconfigurationstmtContext) ALTER(i int) antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserALTER, i)
}

func (s *AltertsconfigurationstmtContext) TEXT_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserTEXT_P, 0)
}

func (s *AltertsconfigurationstmtContext) SEARCH() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserSEARCH, 0)
}

func (s *AltertsconfigurationstmtContext) CONFIGURATION() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCONFIGURATION, 0)
}

func (s *AltertsconfigurationstmtContext) AllAny_name() []IAny_nameContext {
	children := s.GetChildren()
	len := 0
	for _, ctx := range children {
		if _, ok := ctx.(IAny_nameContext); ok {
			len++
		}
	}

	tst := make([]IAny_nameContext, len)
	i := 0
	for _, ctx := range children {
		if t, ok := ctx.(IAny_nameContext); ok {
			tst[i] = t.(IAny_nameContext)
			i++
		}
	}

	return tst
}

func (s *AltertsconfigurationstmtContext) Any_name(i int) IAny_nameContext {
	var t antlr.RuleContext
	j := 0
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IAny_nameContext); ok {
			if j == i {
				t = ctx.(antlr.RuleContext)
				break
			}
			j++
		}
	}

	if t == nil {
		return nil
	}

	return t.(IAny_nameContext)
}

func (s *AltertsconfigurationstmtContext) ADD_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserADD_P, 0)
}

func (s *AltertsconfigurationstmtContext) MAPPING() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserMAPPING, 0)
}

func (s *AltertsconfigurationstmtContext) FOR() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserFOR, 0)
}

func (s *AltertsconfigurationstmtContext) Name_list() IName_listContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IName_listContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IName_listContext)
}

func (s *AltertsconfigurationstmtContext) Any_with() IAny_withContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IAny_withContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IAny_withContext)
}

func (s *AltertsconfigurationstmtContext) Any_name_list() IAny_name_listContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IAny_name_listContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IAny_name_listContext)
}

func (s *AltertsconfigurationstmtContext) REPLACE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserREPLACE, 0)
}

func (s *AltertsconfigurationstmtContext) DROP() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserDROP, 0)
}

func (s *AltertsconfigurationstmtContext) IF_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserIF_P, 0)
}

func (s *AltertsconfigurationstmtContext) EXISTS() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserEXISTS, 0)
}

func (s *AltertsconfigurationstmtContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *AltertsconfigurationstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *AltertsconfigurationstmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterAltertsconfigurationstmt(s)
	}
}

func (s *AltertsconfigurationstmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitAltertsconfigurationstmt(s)
	}
}

func (s *AltertsconfigurationstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitAltertsconfigurationstmt(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Altertsconfigurationstmt() (localctx IAltertsconfigurationstmtContext) {
	localctx = NewAltertsconfigurationstmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 838, PostgreSQLParserRULE_altertsconfigurationstmt)
	p.SetState(7422)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 357, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(7350)
			p.Match(PostgreSQLParserALTER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(7351)
			p.Match(PostgreSQLParserTEXT_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(7352)
			p.Match(PostgreSQLParserSEARCH)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(7353)
			p.Match(PostgreSQLParserCONFIGURATION)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(7354)
			p.Any_name()
		}
		{
			p.SetState(7355)
			p.Match(PostgreSQLParserADD_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(7356)
			p.Match(PostgreSQLParserMAPPING)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(7357)
			p.Match(PostgreSQLParserFOR)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(7358)
			p.Name_list()
		}
		{
			p.SetState(7359)
			p.Any_with()
		}
		{
			p.SetState(7360)
			p.Any_name_list()
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(7362)
			p.Match(PostgreSQLParserALTER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(7363)
			p.Match(PostgreSQLParserTEXT_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(7364)
			p.Match(PostgreSQLParserSEARCH)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(7365)
			p.Match(PostgreSQLParserCONFIGURATION)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(7366)
			p.Any_name()
		}
		{
			p.SetState(7367)
			p.Match(PostgreSQLParserALTER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(7368)
			p.Match(PostgreSQLParserMAPPING)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(7369)
			p.Match(PostgreSQLParserFOR)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(7370)
			p.Name_list()
		}
		{
			p.SetState(7371)
			p.Any_with()
		}
		{
			p.SetState(7372)
			p.Any_name_list()
		}

	case 3:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(7374)
			p.Match(PostgreSQLParserALTER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(7375)
			p.Match(PostgreSQLParserTEXT_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(7376)
			p.Match(PostgreSQLParserSEARCH)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(7377)
			p.Match(PostgreSQLParserCONFIGURATION)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(7378)
			p.Any_name()
		}
		{
			p.SetState(7379)
			p.Match(PostgreSQLParserALTER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(7380)
			p.Match(PostgreSQLParserMAPPING)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(7381)
			p.Match(PostgreSQLParserREPLACE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(7382)
			p.Any_name()
		}
		{
			p.SetState(7383)
			p.Any_with()
		}
		{
			p.SetState(7384)
			p.Any_name()
		}

	case 4:
		p.EnterOuterAlt(localctx, 4)
		{
			p.SetState(7386)
			p.Match(PostgreSQLParserALTER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(7387)
			p.Match(PostgreSQLParserTEXT_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(7388)
			p.Match(PostgreSQLParserSEARCH)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(7389)
			p.Match(PostgreSQLParserCONFIGURATION)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(7390)
			p.Any_name()
		}
		{
			p.SetState(7391)
			p.Match(PostgreSQLParserALTER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(7392)
			p.Match(PostgreSQLParserMAPPING)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(7393)
			p.Match(PostgreSQLParserFOR)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(7394)
			p.Name_list()
		}
		{
			p.SetState(7395)
			p.Match(PostgreSQLParserREPLACE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(7396)
			p.Any_name()
		}
		{
			p.SetState(7397)
			p.Any_with()
		}
		{
			p.SetState(7398)
			p.Any_name()
		}

	case 5:
		p.EnterOuterAlt(localctx, 5)
		{
			p.SetState(7400)
			p.Match(PostgreSQLParserALTER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(7401)
			p.Match(PostgreSQLParserTEXT_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(7402)
			p.Match(PostgreSQLParserSEARCH)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(7403)
			p.Match(PostgreSQLParserCONFIGURATION)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(7404)
			p.Any_name()
		}
		{
			p.SetState(7405)
			p.Match(PostgreSQLParserDROP)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(7406)
			p.Match(PostgreSQLParserMAPPING)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(7407)
			p.Match(PostgreSQLParserFOR)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(7408)
			p.Name_list()
		}

	case 6:
		p.EnterOuterAlt(localctx, 6)
		{
			p.SetState(7410)
			p.Match(PostgreSQLParserALTER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(7411)
			p.Match(PostgreSQLParserTEXT_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(7412)
			p.Match(PostgreSQLParserSEARCH)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(7413)
			p.Match(PostgreSQLParserCONFIGURATION)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(7414)
			p.Any_name()
		}
		{
			p.SetState(7415)
			p.Match(PostgreSQLParserDROP)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(7416)
			p.Match(PostgreSQLParserMAPPING)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(7417)
			p.Match(PostgreSQLParserIF_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(7418)
			p.Match(PostgreSQLParserEXISTS)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(7419)
			p.Match(PostgreSQLParserFOR)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(7420)
			p.Name_list()
		}

	case antlr.ATNInvalidAltNumber:
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IAny_withContext is an interface to support dynamic dispatch.
type IAny_withContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	WITH() antlr.TerminalNode

	// IsAny_withContext differentiates from other interfaces.
	IsAny_withContext()
}

type Any_withContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyAny_withContext() *Any_withContext {
	var p = new(Any_withContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_any_with
	return p
}

func InitEmptyAny_withContext(p *Any_withContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_any_with
}

func (*Any_withContext) IsAny_withContext() {}

func NewAny_withContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Any_withContext {
	var p = new(Any_withContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_any_with

	return p
}

func (s *Any_withContext) GetParser() antlr.Parser { return s.parser }

func (s *Any_withContext) WITH() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserWITH, 0)
}

func (s *Any_withContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Any_withContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Any_withContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterAny_with(s)
	}
}

func (s *Any_withContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitAny_with(s)
	}
}

func (s *Any_withContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitAny_with(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Any_with() (localctx IAny_withContext) {
	localctx = NewAny_withContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 840, PostgreSQLParserRULE_any_with)
	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(7424)
		p.Match(PostgreSQLParserWITH)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// ICreateconversionstmtContext is an interface to support dynamic dispatch.
type ICreateconversionstmtContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	CREATE() antlr.TerminalNode
	Opt_default() IOpt_defaultContext
	CONVERSION_P() antlr.TerminalNode
	AllAny_name() []IAny_nameContext
	Any_name(i int) IAny_nameContext
	FOR() antlr.TerminalNode
	AllSconst() []ISconstContext
	Sconst(i int) ISconstContext
	TO() antlr.TerminalNode
	FROM() antlr.TerminalNode

	// IsCreateconversionstmtContext differentiates from other interfaces.
	IsCreateconversionstmtContext()
}

type CreateconversionstmtContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyCreateconversionstmtContext() *CreateconversionstmtContext {
	var p = new(CreateconversionstmtContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_createconversionstmt
	return p
}

func InitEmptyCreateconversionstmtContext(p *CreateconversionstmtContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_createconversionstmt
}

func (*CreateconversionstmtContext) IsCreateconversionstmtContext() {}

func NewCreateconversionstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CreateconversionstmtContext {
	var p = new(CreateconversionstmtContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_createconversionstmt

	return p
}

func (s *CreateconversionstmtContext) GetParser() antlr.Parser { return s.parser }

func (s *CreateconversionstmtContext) CREATE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCREATE, 0)
}

func (s *CreateconversionstmtContext) Opt_default() IOpt_defaultContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOpt_defaultContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOpt_defaultContext)
}

func (s *CreateconversionstmtContext) CONVERSION_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCONVERSION_P, 0)
}

func (s *CreateconversionstmtContext) AllAny_name() []IAny_nameContext {
	children := s.GetChildren()
	len := 0
	for _, ctx := range children {
		if _, ok := ctx.(IAny_nameContext); ok {
			len++
		}
	}

	tst := make([]IAny_nameContext, len)
	i := 0
	for _, ctx := range children {
		if t, ok := ctx.(IAny_nameContext); ok {
			tst[i] = t.(IAny_nameContext)
			i++
		}
	}

	return tst
}

func (s *CreateconversionstmtContext) Any_name(i int) IAny_nameContext {
	var t antlr.RuleContext
	j := 0
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IAny_nameContext); ok {
			if j == i {
				t = ctx.(antlr.RuleContext)
				break
			}
			j++
		}
	}

	if t == nil {
		return nil
	}

	return t.(IAny_nameContext)
}

func (s *CreateconversionstmtContext) FOR() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserFOR, 0)
}

func (s *CreateconversionstmtContext) AllSconst() []ISconstContext {
	children := s.GetChildren()
	len := 0
	for _, ctx := range children {
		if _, ok := ctx.(ISconstContext); ok {
			len++
		}
	}

	tst := make([]ISconstContext, len)
	i := 0
	for _, ctx := range children {
		if t, ok := ctx.(ISconstContext); ok {
			tst[i] = t.(ISconstContext)
			i++
		}
	}

	return tst
}

func (s *CreateconversionstmtContext) Sconst(i int) ISconstContext {
	var t antlr.RuleContext
	j := 0
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ISconstContext); ok {
			if j == i {
				t = ctx.(antlr.RuleContext)
				break
			}
			j++
		}
	}

	if t == nil {
		return nil
	}

	return t.(ISconstContext)
}

func (s *CreateconversionstmtContext) TO() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserTO, 0)
}

func (s *CreateconversionstmtContext) FROM() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserFROM, 0)
}

func (s *CreateconversionstmtContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *CreateconversionstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *CreateconversionstmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterCreateconversionstmt(s)
	}
}

func (s *CreateconversionstmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitCreateconversionstmt(s)
	}
}

func (s *CreateconversionstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitCreateconversionstmt(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Createconversionstmt() (localctx ICreateconversionstmtContext) {
	localctx = NewCreateconversionstmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 842, PostgreSQLParserRULE_createconversionstmt)
	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(7426)
		p.Match(PostgreSQLParserCREATE)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(7427)
		p.Opt_default()
	}
	{
		p.SetState(7428)
		p.Match(PostgreSQLParserCONVERSION_P)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(7429)
		p.Any_name()
	}
	{
		p.SetState(7430)
		p.Match(PostgreSQLParserFOR)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(7431)
		p.Sconst()
	}
	{
		p.SetState(7432)
		p.Match(PostgreSQLParserTO)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(7433)
		p.Sconst()
	}
	{
		p.SetState(7434)
		p.Match(PostgreSQLParserFROM)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(7435)
		p.Any_name()
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IClusterstmtContext is an interface to support dynamic dispatch.
type IClusterstmtContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	CLUSTER() antlr.TerminalNode
	Opt_verbose() IOpt_verboseContext
	Qualified_name() IQualified_nameContext
	Cluster_index_specification() ICluster_index_specificationContext
	Name() INameContext
	ON() antlr.TerminalNode

	// IsClusterstmtContext differentiates from other interfaces.
	IsClusterstmtContext()
}

type ClusterstmtContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyClusterstmtContext() *ClusterstmtContext {
	var p = new(ClusterstmtContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_clusterstmt
	return p
}

func InitEmptyClusterstmtContext(p *ClusterstmtContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_clusterstmt
}

func (*ClusterstmtContext) IsClusterstmtContext() {}

func NewClusterstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ClusterstmtContext {
	var p = new(ClusterstmtContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_clusterstmt

	return p
}

func (s *ClusterstmtContext) GetParser() antlr.Parser { return s.parser }

func (s *ClusterstmtContext) CLUSTER() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCLUSTER, 0)
}

func (s *ClusterstmtContext) Opt_verbose() IOpt_verboseContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOpt_verboseContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOpt_verboseContext)
}

func (s *ClusterstmtContext) Qualified_name() IQualified_nameContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IQualified_nameContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IQualified_nameContext)
}

func (s *ClusterstmtContext) Cluster_index_specification() ICluster_index_specificationContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ICluster_index_specificationContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ICluster_index_specificationContext)
}

func (s *ClusterstmtContext) Name() INameContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(INameContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(INameContext)
}

func (s *ClusterstmtContext) ON() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserON, 0)
}

func (s *ClusterstmtContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *ClusterstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *ClusterstmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterClusterstmt(s)
	}
}

func (s *ClusterstmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitClusterstmt(s)
	}
}

func (s *ClusterstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitClusterstmt(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Clusterstmt() (localctx IClusterstmtContext) {
	localctx = NewClusterstmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 844, PostgreSQLParserRULE_clusterstmt)
	p.SetState(7450)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 358, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(7437)
			p.Match(PostgreSQLParserCLUSTER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(7438)
			p.Opt_verbose()
		}
		{
			p.SetState(7439)
			p.Qualified_name()
		}
		{
			p.SetState(7440)
			p.Cluster_index_specification()
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(7442)
			p.Match(PostgreSQLParserCLUSTER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(7443)
			p.Opt_verbose()
		}

	case 3:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(7444)
			p.Match(PostgreSQLParserCLUSTER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(7445)
			p.Opt_verbose()
		}
		{
			p.SetState(7446)
			p.Name()
		}
		{
			p.SetState(7447)
			p.Match(PostgreSQLParserON)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(7448)
			p.Qualified_name()
		}

	case antlr.ATNInvalidAltNumber:
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// ICluster_index_specificationContext is an interface to support dynamic dispatch.
type ICluster_index_specificationContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	USING() antlr.TerminalNode
	Name() INameContext

	// IsCluster_index_specificationContext differentiates from other interfaces.
	IsCluster_index_specificationContext()
}

type Cluster_index_specificationContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyCluster_index_specificationContext() *Cluster_index_specificationContext {
	var p = new(Cluster_index_specificationContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_cluster_index_specification
	return p
}

func InitEmptyCluster_index_specificationContext(p *Cluster_index_specificationContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_cluster_index_specification
}

func (*Cluster_index_specificationContext) IsCluster_index_specificationContext() {}

func NewCluster_index_specificationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Cluster_index_specificationContext {
	var p = new(Cluster_index_specificationContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_cluster_index_specification

	return p
}

func (s *Cluster_index_specificationContext) GetParser() antlr.Parser { return s.parser }

func (s *Cluster_index_specificationContext) USING() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserUSING, 0)
}

func (s *Cluster_index_specificationContext) Name() INameContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(INameContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(INameContext)
}

func (s *Cluster_index_specificationContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Cluster_index_specificationContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Cluster_index_specificationContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterCluster_index_specification(s)
	}
}

func (s *Cluster_index_specificationContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitCluster_index_specification(s)
	}
}

func (s *Cluster_index_specificationContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitCluster_index_specification(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Cluster_index_specification() (localctx ICluster_index_specificationContext) {
	localctx = NewCluster_index_specificationContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 846, PostgreSQLParserRULE_cluster_index_specification)
	p.SetState(7455)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetTokenStream().LA(1) {
	case PostgreSQLParserUSING:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(7452)
			p.Match(PostgreSQLParserUSING)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(7453)
			p.Name()
		}

	case PostgreSQLParserEOF, PostgreSQLParserOPEN_PAREN, PostgreSQLParserSEMI, PostgreSQLParserANALYSE, PostgreSQLParserANALYZE, PostgreSQLParserCREATE, PostgreSQLParserDO, PostgreSQLParserFETCH, PostgreSQLParserGRANT, PostgreSQLParserINTO, PostgreSQLParserSELECT, PostgreSQLParserTABLE, PostgreSQLParserWITH, PostgreSQLParserABORT_P, PostgreSQLParserALTER, PostgreSQLParserBEGIN_P, PostgreSQLParserCHECKPOINT, PostgreSQLParserCLOSE, PostgreSQLParserCLUSTER, PostgreSQLParserCOMMENT, PostgreSQLParserCOMMIT, PostgreSQLParserCOPY, PostgreSQLParserDEALLOCATE, PostgreSQLParserDECLARE, PostgreSQLParserDELETE_P, PostgreSQLParserDISCARD, PostgreSQLParserDROP, PostgreSQLParserEXECUTE, PostgreSQLParserEXPLAIN, PostgreSQLParserINSERT, PostgreSQLParserLISTEN, PostgreSQLParserLOAD, PostgreSQLParserLOCK_P, PostgreSQLParserMERGE, PostgreSQLParserMOVE, PostgreSQLParserNOTIFY, PostgreSQLParserPREPARE, PostgreSQLParserREASSIGN, PostgreSQLParserREFRESH, PostgreSQLParserREINDEX, PostgreSQLParserRELEASE, PostgreSQLParserRESET, PostgreSQLParserREVOKE, PostgreSQLParserROLLBACK, PostgreSQLParserSAVEPOINT, PostgreSQLParserSECURITY, PostgreSQLParserSET, PostgreSQLParserSHOW, PostgreSQLParserSTART, PostgreSQLParserTRUNCATE, PostgreSQLParserUNLISTEN, PostgreSQLParserUPDATE, PostgreSQLParserVACUUM, PostgreSQLParserVALUES, PostgreSQLParserCALL, PostgreSQLParserIMPORT_P, PostgreSQLParserEND_P, PostgreSQLParserMetaCommand:
		p.EnterOuterAlt(localctx, 2)

	default:
		p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IVacuumstmtContext is an interface to support dynamic dispatch.
type IVacuumstmtContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	VACUUM() antlr.TerminalNode
	Opt_full() IOpt_fullContext
	Opt_freeze() IOpt_freezeContext
	Opt_verbose() IOpt_verboseContext
	Opt_analyze() IOpt_analyzeContext
	Opt_vacuum_relation_list() IOpt_vacuum_relation_listContext
	OPEN_PAREN() antlr.TerminalNode
	Vac_analyze_option_list() IVac_analyze_option_listContext
	CLOSE_PAREN() antlr.TerminalNode

	// IsVacuumstmtContext differentiates from other interfaces.
	IsVacuumstmtContext()
}

type VacuumstmtContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyVacuumstmtContext() *VacuumstmtContext {
	var p = new(VacuumstmtContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_vacuumstmt
	return p
}

func InitEmptyVacuumstmtContext(p *VacuumstmtContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_vacuumstmt
}

func (*VacuumstmtContext) IsVacuumstmtContext() {}

func NewVacuumstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *VacuumstmtContext {
	var p = new(VacuumstmtContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_vacuumstmt

	return p
}

func (s *VacuumstmtContext) GetParser() antlr.Parser { return s.parser }

func (s *VacuumstmtContext) VACUUM() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserVACUUM, 0)
}

func (s *VacuumstmtContext) Opt_full() IOpt_fullContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOpt_fullContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOpt_fullContext)
}

func (s *VacuumstmtContext) Opt_freeze() IOpt_freezeContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOpt_freezeContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOpt_freezeContext)
}

func (s *VacuumstmtContext) Opt_verbose() IOpt_verboseContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOpt_verboseContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOpt_verboseContext)
}

func (s *VacuumstmtContext) Opt_analyze() IOpt_analyzeContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOpt_analyzeContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOpt_analyzeContext)
}

func (s *VacuumstmtContext) Opt_vacuum_relation_list() IOpt_vacuum_relation_listContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOpt_vacuum_relation_listContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOpt_vacuum_relation_listContext)
}

func (s *VacuumstmtContext) OPEN_PAREN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserOPEN_PAREN, 0)
}

func (s *VacuumstmtContext) Vac_analyze_option_list() IVac_analyze_option_listContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IVac_analyze_option_listContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IVac_analyze_option_listContext)
}

func (s *VacuumstmtContext) CLOSE_PAREN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCLOSE_PAREN, 0)
}

func (s *VacuumstmtContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *VacuumstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *VacuumstmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterVacuumstmt(s)
	}
}

func (s *VacuumstmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitVacuumstmt(s)
	}
}

func (s *VacuumstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitVacuumstmt(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Vacuumstmt() (localctx IVacuumstmtContext) {
	localctx = NewVacuumstmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 848, PostgreSQLParserRULE_vacuumstmt)
	p.SetState(7470)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 360, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(7457)
			p.Match(PostgreSQLParserVACUUM)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(7458)
			p.Opt_full()
		}
		{
			p.SetState(7459)
			p.Opt_freeze()
		}
		{
			p.SetState(7460)
			p.Opt_verbose()
		}
		{
			p.SetState(7461)
			p.Opt_analyze()
		}
		{
			p.SetState(7462)
			p.Opt_vacuum_relation_list()
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(7464)
			p.Match(PostgreSQLParserVACUUM)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(7465)
			p.Match(PostgreSQLParserOPEN_PAREN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(7466)
			p.Vac_analyze_option_list()
		}
		{
			p.SetState(7467)
			p.Match(PostgreSQLParserCLOSE_PAREN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(7468)
			p.Opt_vacuum_relation_list()
		}

	case antlr.ATNInvalidAltNumber:
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IAnalyzestmtContext is an interface to support dynamic dispatch.
type IAnalyzestmtContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Analyze_keyword() IAnalyze_keywordContext
	Opt_verbose() IOpt_verboseContext
	Opt_vacuum_relation_list() IOpt_vacuum_relation_listContext
	OPEN_PAREN() antlr.TerminalNode
	Vac_analyze_option_list() IVac_analyze_option_listContext
	CLOSE_PAREN() antlr.TerminalNode

	// IsAnalyzestmtContext differentiates from other interfaces.
	IsAnalyzestmtContext()
}

type AnalyzestmtContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyAnalyzestmtContext() *AnalyzestmtContext {
	var p = new(AnalyzestmtContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_analyzestmt
	return p
}

func InitEmptyAnalyzestmtContext(p *AnalyzestmtContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_analyzestmt
}

func (*AnalyzestmtContext) IsAnalyzestmtContext() {}

func NewAnalyzestmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AnalyzestmtContext {
	var p = new(AnalyzestmtContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_analyzestmt

	return p
}

func (s *AnalyzestmtContext) GetParser() antlr.Parser { return s.parser }

func (s *AnalyzestmtContext) Analyze_keyword() IAnalyze_keywordContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IAnalyze_keywordContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IAnalyze_keywordContext)
}

func (s *AnalyzestmtContext) Opt_verbose() IOpt_verboseContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOpt_verboseContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOpt_verboseContext)
}

func (s *AnalyzestmtContext) Opt_vacuum_relation_list() IOpt_vacuum_relation_listContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOpt_vacuum_relation_listContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOpt_vacuum_relation_listContext)
}

func (s *AnalyzestmtContext) OPEN_PAREN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserOPEN_PAREN, 0)
}

func (s *AnalyzestmtContext) Vac_analyze_option_list() IVac_analyze_option_listContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IVac_analyze_option_listContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IVac_analyze_option_listContext)
}

func (s *AnalyzestmtContext) CLOSE_PAREN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCLOSE_PAREN, 0)
}

func (s *AnalyzestmtContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *AnalyzestmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *AnalyzestmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterAnalyzestmt(s)
	}
}

func (s *AnalyzestmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitAnalyzestmt(s)
	}
}

func (s *AnalyzestmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitAnalyzestmt(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Analyzestmt() (localctx IAnalyzestmtContext) {
	localctx = NewAnalyzestmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 850, PostgreSQLParserRULE_analyzestmt)
	p.SetState(7482)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 361, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(7472)
			p.Analyze_keyword()
		}
		{
			p.SetState(7473)
			p.Opt_verbose()
		}
		{
			p.SetState(7474)
			p.Opt_vacuum_relation_list()
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(7476)
			p.Analyze_keyword()
		}
		{
			p.SetState(7477)
			p.Match(PostgreSQLParserOPEN_PAREN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(7478)
			p.Vac_analyze_option_list()
		}
		{
			p.SetState(7479)
			p.Match(PostgreSQLParserCLOSE_PAREN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(7480)
			p.Opt_vacuum_relation_list()
		}

	case antlr.ATNInvalidAltNumber:
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IVac_analyze_option_listContext is an interface to support dynamic dispatch.
type IVac_analyze_option_listContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	AllVac_analyze_option_elem() []IVac_analyze_option_elemContext
	Vac_analyze_option_elem(i int) IVac_analyze_option_elemContext
	AllCOMMA() []antlr.TerminalNode
	COMMA(i int) antlr.TerminalNode

	// IsVac_analyze_option_listContext differentiates from other interfaces.
	IsVac_analyze_option_listContext()
}

type Vac_analyze_option_listContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyVac_analyze_option_listContext() *Vac_analyze_option_listContext {
	var p = new(Vac_analyze_option_listContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_vac_analyze_option_list
	return p
}

func InitEmptyVac_analyze_option_listContext(p *Vac_analyze_option_listContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_vac_analyze_option_list
}

func (*Vac_analyze_option_listContext) IsVac_analyze_option_listContext() {}

func NewVac_analyze_option_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Vac_analyze_option_listContext {
	var p = new(Vac_analyze_option_listContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_vac_analyze_option_list

	return p
}

func (s *Vac_analyze_option_listContext) GetParser() antlr.Parser { return s.parser }

func (s *Vac_analyze_option_listContext) AllVac_analyze_option_elem() []IVac_analyze_option_elemContext {
	children := s.GetChildren()
	len := 0
	for _, ctx := range children {
		if _, ok := ctx.(IVac_analyze_option_elemContext); ok {
			len++
		}
	}

	tst := make([]IVac_analyze_option_elemContext, len)
	i := 0
	for _, ctx := range children {
		if t, ok := ctx.(IVac_analyze_option_elemContext); ok {
			tst[i] = t.(IVac_analyze_option_elemContext)
			i++
		}
	}

	return tst
}

func (s *Vac_analyze_option_listContext) Vac_analyze_option_elem(i int) IVac_analyze_option_elemContext {
	var t antlr.RuleContext
	j := 0
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IVac_analyze_option_elemContext); ok {
			if j == i {
				t = ctx.(antlr.RuleContext)
				break
			}
			j++
		}
	}

	if t == nil {
		return nil
	}

	return t.(IVac_analyze_option_elemContext)
}

func (s *Vac_analyze_option_listContext) AllCOMMA() []antlr.TerminalNode {
	return s.GetTokens(PostgreSQLParserCOMMA)
}

func (s *Vac_analyze_option_listContext) COMMA(i int) antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCOMMA, i)
}

func (s *Vac_analyze_option_listContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Vac_analyze_option_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Vac_analyze_option_listContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterVac_analyze_option_list(s)
	}
}

func (s *Vac_analyze_option_listContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitVac_analyze_option_list(s)
	}
}

func (s *Vac_analyze_option_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitVac_analyze_option_list(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Vac_analyze_option_list() (localctx IVac_analyze_option_listContext) {
	localctx = NewVac_analyze_option_listContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 852, PostgreSQLParserRULE_vac_analyze_option_list)
	var _la int

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(7484)
		p.Vac_analyze_option_elem()
	}
	p.SetState(7489)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}
	_la = p.GetTokenStream().LA(1)

	for _la == PostgreSQLParserCOMMA {
		{
			p.SetState(7485)
			p.Match(PostgreSQLParserCOMMA)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(7486)
			p.Vac_analyze_option_elem()
		}

		p.SetState(7491)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}
		_la = p.GetTokenStream().LA(1)
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IAnalyze_keywordContext is an interface to support dynamic dispatch.
type IAnalyze_keywordContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	ANALYZE() antlr.TerminalNode
	ANALYSE() antlr.TerminalNode

	// IsAnalyze_keywordContext differentiates from other interfaces.
	IsAnalyze_keywordContext()
}

type Analyze_keywordContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyAnalyze_keywordContext() *Analyze_keywordContext {
	var p = new(Analyze_keywordContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_analyze_keyword
	return p
}

func InitEmptyAnalyze_keywordContext(p *Analyze_keywordContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_analyze_keyword
}

func (*Analyze_keywordContext) IsAnalyze_keywordContext() {}

func NewAnalyze_keywordContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Analyze_keywordContext {
	var p = new(Analyze_keywordContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_analyze_keyword

	return p
}

func (s *Analyze_keywordContext) GetParser() antlr.Parser { return s.parser }

func (s *Analyze_keywordContext) ANALYZE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserANALYZE, 0)
}

func (s *Analyze_keywordContext) ANALYSE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserANALYSE, 0)
}

func (s *Analyze_keywordContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Analyze_keywordContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Analyze_keywordContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterAnalyze_keyword(s)
	}
}

func (s *Analyze_keywordContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitAnalyze_keyword(s)
	}
}

func (s *Analyze_keywordContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitAnalyze_keyword(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Analyze_keyword() (localctx IAnalyze_keywordContext) {
	localctx = NewAnalyze_keywordContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 854, PostgreSQLParserRULE_analyze_keyword)
	var _la int

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(7492)
		_la = p.GetTokenStream().LA(1)

		if !(_la == PostgreSQLParserANALYSE || _la == PostgreSQLParserANALYZE) {
			p.GetErrorHandler().RecoverInline(p)
		} else {
			p.GetErrorHandler().ReportMatch(p)
			p.Consume()
		}
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IVac_analyze_option_elemContext is an interface to support dynamic dispatch.
type IVac_analyze_option_elemContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Vac_analyze_option_name() IVac_analyze_option_nameContext
	Vac_analyze_option_arg() IVac_analyze_option_argContext

	// IsVac_analyze_option_elemContext differentiates from other interfaces.
	IsVac_analyze_option_elemContext()
}

type Vac_analyze_option_elemContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyVac_analyze_option_elemContext() *Vac_analyze_option_elemContext {
	var p = new(Vac_analyze_option_elemContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_vac_analyze_option_elem
	return p
}

func InitEmptyVac_analyze_option_elemContext(p *Vac_analyze_option_elemContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_vac_analyze_option_elem
}

func (*Vac_analyze_option_elemContext) IsVac_analyze_option_elemContext() {}

func NewVac_analyze_option_elemContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Vac_analyze_option_elemContext {
	var p = new(Vac_analyze_option_elemContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_vac_analyze_option_elem

	return p
}

func (s *Vac_analyze_option_elemContext) GetParser() antlr.Parser { return s.parser }

func (s *Vac_analyze_option_elemContext) Vac_analyze_option_name() IVac_analyze_option_nameContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IVac_analyze_option_nameContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IVac_analyze_option_nameContext)
}

func (s *Vac_analyze_option_elemContext) Vac_analyze_option_arg() IVac_analyze_option_argContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IVac_analyze_option_argContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IVac_analyze_option_argContext)
}

func (s *Vac_analyze_option_elemContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Vac_analyze_option_elemContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Vac_analyze_option_elemContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterVac_analyze_option_elem(s)
	}
}

func (s *Vac_analyze_option_elemContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitVac_analyze_option_elem(s)
	}
}

func (s *Vac_analyze_option_elemContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitVac_analyze_option_elem(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Vac_analyze_option_elem() (localctx IVac_analyze_option_elemContext) {
	localctx = NewVac_analyze_option_elemContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 856, PostgreSQLParserRULE_vac_analyze_option_elem)
	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(7494)
		p.Vac_analyze_option_name()
	}
	{
		p.SetState(7495)
		p.Vac_analyze_option_arg()
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IVac_analyze_option_nameContext is an interface to support dynamic dispatch.
type IVac_analyze_option_nameContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Nonreservedword() INonreservedwordContext
	Analyze_keyword() IAnalyze_keywordContext

	// IsVac_analyze_option_nameContext differentiates from other interfaces.
	IsVac_analyze_option_nameContext()
}

type Vac_analyze_option_nameContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyVac_analyze_option_nameContext() *Vac_analyze_option_nameContext {
	var p = new(Vac_analyze_option_nameContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_vac_analyze_option_name
	return p
}

func InitEmptyVac_analyze_option_nameContext(p *Vac_analyze_option_nameContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_vac_analyze_option_name
}

func (*Vac_analyze_option_nameContext) IsVac_analyze_option_nameContext() {}

func NewVac_analyze_option_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Vac_analyze_option_nameContext {
	var p = new(Vac_analyze_option_nameContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_vac_analyze_option_name

	return p
}

func (s *Vac_analyze_option_nameContext) GetParser() antlr.Parser { return s.parser }

func (s *Vac_analyze_option_nameContext) Nonreservedword() INonreservedwordContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(INonreservedwordContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(INonreservedwordContext)
}

func (s *Vac_analyze_option_nameContext) Analyze_keyword() IAnalyze_keywordContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IAnalyze_keywordContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IAnalyze_keywordContext)
}

func (s *Vac_analyze_option_nameContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Vac_analyze_option_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Vac_analyze_option_nameContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterVac_analyze_option_name(s)
	}
}

func (s *Vac_analyze_option_nameContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitVac_analyze_option_name(s)
	}
}

func (s *Vac_analyze_option_nameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitVac_analyze_option_name(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Vac_analyze_option_name() (localctx IVac_analyze_option_nameContext) {
	localctx = NewVac_analyze_option_nameContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 858, PostgreSQLParserRULE_vac_analyze_option_name)
	p.SetState(7499)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetTokenStream().LA(1) {
	case PostgreSQLParserAND, PostgreSQLParserARRAY, PostgreSQLParserCOLLATE, PostgreSQLParserCOLUMN, PostgreSQLParserCONSTRAINT, PostgreSQLParserDEFAULT, PostgreSQLParserDO, PostgreSQLParserFETCH, PostgreSQLParserTABLE, PostgreSQLParserAUTHORIZATION, PostgreSQLParserBINARY, PostgreSQLParserCOLLATION, PostgreSQLParserCONCURRENTLY, PostgreSQLParserCROSS, PostgreSQLParserCURRENT_SCHEMA, PostgreSQLParserFREEZE, PostgreSQLParserFULL, PostgreSQLParserILIKE, PostgreSQLParserINNER_P, PostgreSQLParserIS, PostgreSQLParserISNULL, PostgreSQLParserJOIN, PostgreSQLParserLIKE, PostgreSQLParserNATURAL, PostgreSQLParserNOTNULL, PostgreSQLParserOUTER_P, PostgreSQLParserOVER, PostgreSQLParserOVERLAPS, PostgreSQLParserSIMILAR, PostgreSQLParserVERBOSE, PostgreSQLParserABORT_P, PostgreSQLParserABSOLUTE_P, PostgreSQLParserACCESS, PostgreSQLParserACTION, PostgreSQLParserADD_P, PostgreSQLParserADMIN, PostgreSQLParserAFTER, PostgreSQLParserAGGREGATE, PostgreSQLParserALSO, PostgreSQLParserALTER, PostgreSQLParserALWAYS, PostgreSQLParserASSERTION, PostgreSQLParserASSIGNMENT, PostgreSQLParserAT, PostgreSQLParserATTRIBUTE, PostgreSQLParserBACKWARD, PostgreSQLParserBEFORE, PostgreSQLParserBEGIN_P, PostgreSQLParserBY, PostgreSQLParserCACHE, PostgreSQLParserCALLED, PostgreSQLParserCASCADE, PostgreSQLParserCASCADED, PostgreSQLParserCATALOG, PostgreSQLParserCHAIN, PostgreSQLParserCHARACTERISTICS, PostgreSQLParserCHECKPOINT, PostgreSQLParserCLASS, PostgreSQLParserCLOSE, PostgreSQLParserCLUSTER, PostgreSQLParserCOMMENT, PostgreSQLParserCOMMENTS, PostgreSQLParserCOMMIT, PostgreSQLParserCOMMITTED, PostgreSQLParserCONFIGURATION, PostgreSQLParserCONNECTION, PostgreSQLParserCONSTRAINTS, PostgreSQLParserCONTENT_P, PostgreSQLParserCONTINUE_P, PostgreSQLParserCONVERSION_P, PostgreSQLParserCOPY, PostgreSQLParserCOST, PostgreSQLParserCSV, PostgreSQLParserCURSOR, PostgreSQLParserCYCLE, PostgreSQLParserDATA_P, PostgreSQLParserDATABASE, PostgreSQLParserDAY_P, PostgreSQLParserDEALLOCATE, PostgreSQLParserDECLARE, PostgreSQLParserDEFAULTS, PostgreSQLParserDEFERRED, PostgreSQLParserDEFINER, PostgreSQLParserDELETE_P, PostgreSQLParserDELIMITER, PostgreSQLParserDELIMITERS, PostgreSQLParserDICTIONARY, PostgreSQLParserDISABLE_P, PostgreSQLParserDISCARD, PostgreSQLParserDOCUMENT_P, PostgreSQLParserDOMAIN_P, PostgreSQLParserDOUBLE_P, PostgreSQLParserDROP, PostgreSQLParserEACH, PostgreSQLParserENABLE_P, PostgreSQLParserENCODING, PostgreSQLParserENCRYPTED, PostgreSQLParserENUM_P, PostgreSQLParserESCAPE, PostgreSQLParserEVENT, PostgreSQLParserEXCLUDE, PostgreSQLParserEXCLUDING, PostgreSQLParserEXCLUSIVE, PostgreSQLParserEXECUTE, PostgreSQLParserEXPLAIN, PostgreSQLParserEXTENSION, PostgreSQLParserEXTERNAL, PostgreSQLParserFAMILY, PostgreSQLParserFIRST_P, PostgreSQLParserFOLLOWING, PostgreSQLParserFORCE, PostgreSQLParserFORWARD, PostgreSQLParserFUNCTION, PostgreSQLParserFUNCTIONS, PostgreSQLParserGLOBAL, PostgreSQLParserGRANTED, PostgreSQLParserHANDLER, PostgreSQLParserHEADER_P, PostgreSQLParserHOLD, PostgreSQLParserHOUR_P, PostgreSQLParserIDENTITY_P, PostgreSQLParserIF_P, PostgreSQLParserIMMEDIATE, PostgreSQLParserIMMUTABLE, PostgreSQLParserIMPLICIT_P, PostgreSQLParserINCLUDING, PostgreSQLParserINCREMENT, PostgreSQLParserINDEX, PostgreSQLParserINDEXES, PostgreSQLParserINHERIT, PostgreSQLParserINHERITS, PostgreSQLParserINLINE_P, PostgreSQLParserINSENSITIVE, PostgreSQLParserINSERT, PostgreSQLParserINSTEAD, PostgreSQLParserINVOKER, PostgreSQLParserISOLATION, PostgreSQLParserKEY, PostgreSQLParserLABEL, PostgreSQLParserLANGUAGE, PostgreSQLParserLARGE_P, PostgreSQLParserLAST_P, PostgreSQLParserLEAKPROOF, PostgreSQLParserLEVEL, PostgreSQLParserLISTEN, PostgreSQLParserLOAD, PostgreSQLParserLOCAL, PostgreSQLParserLOCATION, PostgreSQLParserLOCK_P, PostgreSQLParserMAPPING, PostgreSQLParserMATCH, PostgreSQLParserMATERIALIZED, PostgreSQLParserMAXVALUE, PostgreSQLParserMINUTE_P, PostgreSQLParserMINVALUE, PostgreSQLParserMODE, PostgreSQLParserMONTH_P, PostgreSQLParserMOVE, PostgreSQLParserNAME_P, PostgreSQLParserNAMES, PostgreSQLParserNEXT, PostgreSQLParserNO, PostgreSQLParserNOTHING, PostgreSQLParserNOTIFY, PostgreSQLParserNOWAIT, PostgreSQLParserNULLS_P, PostgreSQLParserOBJECT_P, PostgreSQLParserOF, PostgreSQLParserOFF, PostgreSQLParserOIDS, PostgreSQLParserOPERATOR, PostgreSQLParserOPTION, PostgreSQLParserOPTIONS, PostgreSQLParserOWNED, PostgreSQLParserOWNER, PostgreSQLParserPARSER, PostgreSQLParserPARTIAL, PostgreSQLParserPARTITION, PostgreSQLParserPASSING, PostgreSQLParserPASSWORD, PostgreSQLParserPLANS, PostgreSQLParserPRECEDING, PostgreSQLParserPREPARE, PostgreSQLParserPREPARED, PostgreSQLParserPRESERVE, PostgreSQLParserPRIOR, PostgreSQLParserPRIVILEGES, PostgreSQLParserPROCEDURAL, PostgreSQLParserPROCEDURE, PostgreSQLParserPROGRAM, PostgreSQLParserQUOTE, PostgreSQLParserRANGE, PostgreSQLParserREAD, PostgreSQLParserREASSIGN, PostgreSQLParserRECHECK, PostgreSQLParserRECURSIVE, PostgreSQLParserREF, PostgreSQLParserREFRESH, PostgreSQLParserREINDEX, PostgreSQLParserRELATIVE_P, PostgreSQLParserRELEASE, PostgreSQLParserRENAME, PostgreSQLParserREPEATABLE, PostgreSQLParserREPLACE, PostgreSQLParserREPLICA, PostgreSQLParserRESET, PostgreSQLParserRESTART, PostgreSQLParserRESTRICT, PostgreSQLParserRETURNS, PostgreSQLParserREVOKE, PostgreSQLParserROLE, PostgreSQLParserROLLBACK, PostgreSQLParserROWS, PostgreSQLParserRULE, PostgreSQLParserSAVEPOINT, PostgreSQLParserSCHEMA, PostgreSQLParserSCROLL, PostgreSQLParserSEARCH, PostgreSQLParserSECOND_P, PostgreSQLParserSECURITY, PostgreSQLParserSEQUENCE, PostgreSQLParserSEQUENCES, PostgreSQLParserSERIALIZABLE, PostgreSQLParserSERVER, PostgreSQLParserSESSION, PostgreSQLParserSET, PostgreSQLParserSHARE, PostgreSQLParserSHOW, PostgreSQLParserSIMPLE, PostgreSQLParserSNAPSHOT, PostgreSQLParserSTABLE, PostgreSQLParserSTANDALONE_P, PostgreSQLParserSTART, PostgreSQLParserSTATEMENT, PostgreSQLParserSTATISTICS, PostgreSQLParserSTDIN, PostgreSQLParserSTDOUT, PostgreSQLParserSTORAGE, PostgreSQLParserSTRICT_P, PostgreSQLParserSTRIP_P, PostgreSQLParserSYSID, PostgreSQLParserSYSTEM_P, PostgreSQLParserTABLES, PostgreSQLParserTABLESPACE, PostgreSQLParserTEMP, PostgreSQLParserTEMPLATE, PostgreSQLParserTEMPORARY, PostgreSQLParserTEXT_P, PostgreSQLParserTRANSACTION, PostgreSQLParserTRIGGER, PostgreSQLParserTRUNCATE, PostgreSQLParserTRUSTED, PostgreSQLParserTYPE_P, PostgreSQLParserTYPES_P, PostgreSQLParserUNBOUNDED, PostgreSQLParserUNCOMMITTED, PostgreSQLParserUNENCRYPTED, PostgreSQLParserUNKNOWN, PostgreSQLParserUNLISTEN, PostgreSQLParserUNLOGGED, PostgreSQLParserUNTIL, PostgreSQLParserUPDATE, PostgreSQLParserVACUUM, PostgreSQLParserVALID, PostgreSQLParserVALIDATE, PostgreSQLParserVALIDATOR, PostgreSQLParserVARYING, PostgreSQLParserVERSION_P, PostgreSQLParserVIEW, PostgreSQLParserVOLATILE, PostgreSQLParserWHITESPACE_P, PostgreSQLParserWITHOUT, PostgreSQLParserWORK, PostgreSQLParserWRAPPER, PostgreSQLParserWRITE, PostgreSQLParserXML_P, PostgreSQLParserYEAR_P, PostgreSQLParserYES_P, PostgreSQLParserZONE, PostgreSQLParserBETWEEN, PostgreSQLParserBIGINT, PostgreSQLParserBIT, PostgreSQLParserBOOLEAN_P, PostgreSQLParserCHAR_P, PostgreSQLParserCHARACTER, PostgreSQLParserCOALESCE, PostgreSQLParserDEC, PostgreSQLParserDECIMAL_P, PostgreSQLParserEXISTS, PostgreSQLParserEXTRACT, PostgreSQLParserFLOAT_P, PostgreSQLParserGREATEST, PostgreSQLParserINOUT, PostgreSQLParserINT_P, PostgreSQLParserINTEGER, PostgreSQLParserINTERVAL, PostgreSQLParserLEAST, PostgreSQLParserNATIONAL, PostgreSQLParserNCHAR, PostgreSQLParserNONE, PostgreSQLParserNULLIF, PostgreSQLParserNUMERIC, PostgreSQLParserOVERLAY, PostgreSQLParserPOSITION, PostgreSQLParserPRECISION, PostgreSQLParserREAL, PostgreSQLParserROW, PostgreSQLParserSETOF, PostgreSQLParserSMALLINT, PostgreSQLParserSUBSTRING, PostgreSQLParserTIME, PostgreSQLParserTIMESTAMP, PostgreSQLParserTREAT, PostgreSQLParserTRIM, PostgreSQLParserVALUES, PostgreSQLParserVARCHAR, PostgreSQLParserXMLATTRIBUTES, PostgreSQLParserXMLCOMMENT, PostgreSQLParserXMLAGG, PostgreSQLParserXML_IS_WELL_FORMED, PostgreSQLParserXML_IS_WELL_FORMED_DOCUMENT, PostgreSQLParserXML_IS_WELL_FORMED_CONTENT, PostgreSQLParserXPATH, PostgreSQLParserXPATH_EXISTS, PostgreSQLParserXMLCONCAT, PostgreSQLParserXMLELEMENT, PostgreSQLParserXMLEXISTS, PostgreSQLParserXMLFOREST, PostgreSQLParserXMLPARSE, PostgreSQLParserXMLPI, PostgreSQLParserXMLROOT, PostgreSQLParserXMLSERIALIZE, PostgreSQLParserCALL, PostgreSQLParserCURRENT_P, PostgreSQLParserATTACH, PostgreSQLParserDETACH, PostgreSQLParserEXPRESSION, PostgreSQLParserGENERATED, PostgreSQLParserLOGGED, PostgreSQLParserSTORED, PostgreSQLParserINCLUDE, PostgreSQLParserROUTINE, PostgreSQLParserTRANSFORM, PostgreSQLParserIMPORT_P, PostgreSQLParserPOLICY, PostgreSQLParserMETHOD, PostgreSQLParserREFERENCING, PostgreSQLParserNEW, PostgreSQLParserOLD, PostgreSQLParserVALUE_P, PostgreSQLParserSUBSCRIPTION, PostgreSQLParserPUBLICATION, PostgreSQLParserOUT_P, PostgreSQLParserROUTINES, PostgreSQLParserSCHEMAS, PostgreSQLParserPROCEDURES, PostgreSQLParserINPUT_P, PostgreSQLParserSUPPORT, PostgreSQLParserPARALLEL, PostgreSQLParserSQL_P, PostgreSQLParserDEPENDS, PostgreSQLParserOVERRIDING, PostgreSQLParserCONFLICT, PostgreSQLParserSKIP_P, PostgreSQLParserLOCKED, PostgreSQLParserTIES, PostgreSQLParserROLLUP, PostgreSQLParserCUBE, PostgreSQLParserGROUPING, PostgreSQLParserSETS, PostgreSQLParserTABLESAMPLE, PostgreSQLParserORDINALITY, PostgreSQLParserXMLTABLE, PostgreSQLParserCOLUMNS, PostgreSQLParserXMLNAMESPACES, PostgreSQLParserROWTYPE, PostgreSQLParserNORMALIZED, PostgreSQLParserWITHIN, PostgreSQLParserFILTER, PostgreSQLParserGROUPS, PostgreSQLParserOTHERS, PostgreSQLParserNFC, PostgreSQLParserNFD, PostgreSQLParserNFKC, PostgreSQLParserNFKD, PostgreSQLParserUESCAPE, PostgreSQLParserVIEWS, PostgreSQLParserNORMALIZE, PostgreSQLParserDUMP, PostgreSQLParserPRINT_STRICT_PARAMS, PostgreSQLParserVARIABLE_CONFLICT, PostgreSQLParserERROR, PostgreSQLParserUSE_VARIABLE, PostgreSQLParserUSE_COLUMN, PostgreSQLParserALIAS, PostgreSQLParserCONSTANT, PostgreSQLParserPERFORM, PostgreSQLParserGET, PostgreSQLParserDIAGNOSTICS, PostgreSQLParserSTACKED, PostgreSQLParserELSIF, PostgreSQLParserREVERSE, PostgreSQLParserSLICE, PostgreSQLParserEXIT, PostgreSQLParserRETURN, PostgreSQLParserQUERY, PostgreSQLParserRAISE, PostgreSQLParserSQLSTATE, PostgreSQLParserDEBUG, PostgreSQLParserLOG, PostgreSQLParserINFO, PostgreSQLParserNOTICE, PostgreSQLParserWARNING, PostgreSQLParserEXCEPTION, PostgreSQLParserASSERT, PostgreSQLParserOPEN, PostgreSQLParserABS, PostgreSQLParserCBRT, PostgreSQLParserCEIL, PostgreSQLParserCEILING, PostgreSQLParserDEGREES, PostgreSQLParserDIV, PostgreSQLParserEXP, PostgreSQLParserFACTORIAL, PostgreSQLParserFLOOR, PostgreSQLParserGCD, PostgreSQLParserLCM, PostgreSQLParserLN, PostgreSQLParserLOG10, PostgreSQLParserMIN_SCALE, PostgreSQLParserMOD, PostgreSQLParserPI, PostgreSQLParserPOWER, PostgreSQLParserRADIANS, PostgreSQLParserROUND, PostgreSQLParserSCALE, PostgreSQLParserSIGN, PostgreSQLParserSQRT, PostgreSQLParserTRIM_SCALE, PostgreSQLParserTRUNC, PostgreSQLParserWIDTH_BUCKET, PostgreSQLParserRANDOM, PostgreSQLParserSETSEED, PostgreSQLParserACOS, PostgreSQLParserACOSD, PostgreSQLParserASIN, PostgreSQLParserASIND, PostgreSQLParserATAN, PostgreSQLParserATAND, PostgreSQLParserATAN2, PostgreSQLParserATAN2D, PostgreSQLParserCOS, PostgreSQLParserCOSD, PostgreSQLParserCOT, PostgreSQLParserCOTD, PostgreSQLParserSIN, PostgreSQLParserSIND, PostgreSQLParserTAN, PostgreSQLParserTAND, PostgreSQLParserSINH, PostgreSQLParserCOSH, PostgreSQLParserTANH, PostgreSQLParserASINH, PostgreSQLParserACOSH, PostgreSQLParserATANH, PostgreSQLParserBIT_LENGTH, PostgreSQLParserCHAR_LENGTH, PostgreSQLParserCHARACTER_LENGTH, PostgreSQLParserLOWER, PostgreSQLParserOCTET_LENGTH, PostgreSQLParserUPPER, PostgreSQLParserASCII, PostgreSQLParserBTRIM, PostgreSQLParserCHR, PostgreSQLParserCONCAT, PostgreSQLParserCONCAT_WS, PostgreSQLParserFORMAT, PostgreSQLParserINITCAP, PostgreSQLParserLENGTH, PostgreSQLParserLPAD, PostgreSQLParserLTRIM, PostgreSQLParserMD5, PostgreSQLParserPARSE_IDENT, PostgreSQLParserPG_CLIENT_ENCODING, PostgreSQLParserQUOTE_IDENT, PostgreSQLParserQUOTE_LITERAL, PostgreSQLParserQUOTE_NULLABLE, PostgreSQLParserREGEXP_COUNT, PostgreSQLParserREGEXP_INSTR, PostgreSQLParserREGEXP_LIKE, PostgreSQLParserREGEXP_MATCH, PostgreSQLParserREGEXP_MATCHES, PostgreSQLParserREGEXP_REPLACE, PostgreSQLParserREGEXP_SPLIT_TO_ARRAY, PostgreSQLParserREGEXP_SPLIT_TO_TABLE, PostgreSQLParserREGEXP_SUBSTR, PostgreSQLParserREPEAT, PostgreSQLParserRPAD, PostgreSQLParserRTRIM, PostgreSQLParserSPLIT_PART, PostgreSQLParserSTARTS_WITH, PostgreSQLParserSTRING_TO_ARRAY, PostgreSQLParserSTRING_TO_TABLE, PostgreSQLParserSTRPOS, PostgreSQLParserSUBSTR, PostgreSQLParserTO_ASCII, PostgreSQLParserTO_HEX, PostgreSQLParserTRANSLATE, PostgreSQLParserUNISTR, PostgreSQLParserAGE, PostgreSQLParserCLOCK_TIMESTAMP, PostgreSQLParserDATE_BIN, PostgreSQLParserDATE_PART, PostgreSQLParserDATE_TRUNC, PostgreSQLParserISFINITE, PostgreSQLParserJUSTIFY_DAYS, PostgreSQLParserJUSTIFY_HOURS, PostgreSQLParserJUSTIFY_INTERVAL, PostgreSQLParserMAKE_DATE, PostgreSQLParserMAKE_INTERVAL, PostgreSQLParserMAKE_TIME, PostgreSQLParserMAKE_TIMESTAMP, PostgreSQLParserMAKE_TIMESTAMPTZ, PostgreSQLParserNOW, PostgreSQLParserSTATEMENT_TIMESTAMP, PostgreSQLParserTIMEOFDAY, PostgreSQLParserTRANSACTION_TIMESTAMP, PostgreSQLParserTO_TIMESTAMP, PostgreSQLParserTO_CHAR, PostgreSQLParserTO_DATE, PostgreSQLParserTO_NUMBER, PostgreSQLParserIdentifier, PostgreSQLParserQuotedIdentifier, PostgreSQLParserUnicodeQuotedIdentifier, PostgreSQLParserPLSQLVARIABLENAME, PostgreSQLParserPLSQLIDENTIFIER:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(7497)
			p.Nonreservedword()
		}

	case PostgreSQLParserANALYSE, PostgreSQLParserANALYZE:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(7498)
			p.Analyze_keyword()
		}

	default:
		p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IVac_analyze_option_argContext is an interface to support dynamic dispatch.
type IVac_analyze_option_argContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Opt_boolean_or_string() IOpt_boolean_or_stringContext
	Numericonly() INumericonlyContext

	// IsVac_analyze_option_argContext differentiates from other interfaces.
	IsVac_analyze_option_argContext()
}

type Vac_analyze_option_argContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyVac_analyze_option_argContext() *Vac_analyze_option_argContext {
	var p = new(Vac_analyze_option_argContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_vac_analyze_option_arg
	return p
}

func InitEmptyVac_analyze_option_argContext(p *Vac_analyze_option_argContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_vac_analyze_option_arg
}

func (*Vac_analyze_option_argContext) IsVac_analyze_option_argContext() {}

func NewVac_analyze_option_argContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Vac_analyze_option_argContext {
	var p = new(Vac_analyze_option_argContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_vac_analyze_option_arg

	return p
}

func (s *Vac_analyze_option_argContext) GetParser() antlr.Parser { return s.parser }

func (s *Vac_analyze_option_argContext) Opt_boolean_or_string() IOpt_boolean_or_stringContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOpt_boolean_or_stringContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOpt_boolean_or_stringContext)
}

func (s *Vac_analyze_option_argContext) Numericonly() INumericonlyContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(INumericonlyContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(INumericonlyContext)
}

func (s *Vac_analyze_option_argContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Vac_analyze_option_argContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Vac_analyze_option_argContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterVac_analyze_option_arg(s)
	}
}

func (s *Vac_analyze_option_argContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitVac_analyze_option_arg(s)
	}
}

func (s *Vac_analyze_option_argContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitVac_analyze_option_arg(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Vac_analyze_option_arg() (localctx IVac_analyze_option_argContext) {
	localctx = NewVac_analyze_option_argContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 860, PostgreSQLParserRULE_vac_analyze_option_arg)
	p.SetState(7504)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetTokenStream().LA(1) {
	case PostgreSQLParserAND, PostgreSQLParserARRAY, PostgreSQLParserCOLLATE, PostgreSQLParserCOLUMN, PostgreSQLParserCONSTRAINT, PostgreSQLParserDEFAULT, PostgreSQLParserDO, PostgreSQLParserFALSE_P, PostgreSQLParserFETCH, PostgreSQLParserON, PostgreSQLParserTABLE, PostgreSQLParserTRUE_P, PostgreSQLParserAUTHORIZATION, PostgreSQLParserBINARY, PostgreSQLParserCOLLATION, PostgreSQLParserCONCURRENTLY, PostgreSQLParserCROSS, PostgreSQLParserCURRENT_SCHEMA, PostgreSQLParserFREEZE, PostgreSQLParserFULL, PostgreSQLParserILIKE, PostgreSQLParserINNER_P, PostgreSQLParserIS, PostgreSQLParserISNULL, PostgreSQLParserJOIN, PostgreSQLParserLIKE, PostgreSQLParserNATURAL, PostgreSQLParserNOTNULL, PostgreSQLParserOUTER_P, PostgreSQLParserOVER, PostgreSQLParserOVERLAPS, PostgreSQLParserSIMILAR, PostgreSQLParserVERBOSE, PostgreSQLParserABORT_P, PostgreSQLParserABSOLUTE_P, PostgreSQLParserACCESS, PostgreSQLParserACTION, PostgreSQLParserADD_P, PostgreSQLParserADMIN, PostgreSQLParserAFTER, PostgreSQLParserAGGREGATE, PostgreSQLParserALSO, PostgreSQLParserALTER, PostgreSQLParserALWAYS, PostgreSQLParserASSERTION, PostgreSQLParserASSIGNMENT, PostgreSQLParserAT, PostgreSQLParserATTRIBUTE, PostgreSQLParserBACKWARD, PostgreSQLParserBEFORE, PostgreSQLParserBEGIN_P, PostgreSQLParserBY, PostgreSQLParserCACHE, PostgreSQLParserCALLED, PostgreSQLParserCASCADE, PostgreSQLParserCASCADED, PostgreSQLParserCATALOG, PostgreSQLParserCHAIN, PostgreSQLParserCHARACTERISTICS, PostgreSQLParserCHECKPOINT, PostgreSQLParserCLASS, PostgreSQLParserCLOSE, PostgreSQLParserCLUSTER, PostgreSQLParserCOMMENT, PostgreSQLParserCOMMENTS, PostgreSQLParserCOMMIT, PostgreSQLParserCOMMITTED, PostgreSQLParserCONFIGURATION, PostgreSQLParserCONNECTION, PostgreSQLParserCONSTRAINTS, PostgreSQLParserCONTENT_P, PostgreSQLParserCONTINUE_P, PostgreSQLParserCONVERSION_P, PostgreSQLParserCOPY, PostgreSQLParserCOST, PostgreSQLParserCSV, PostgreSQLParserCURSOR, PostgreSQLParserCYCLE, PostgreSQLParserDATA_P, PostgreSQLParserDATABASE, PostgreSQLParserDAY_P, PostgreSQLParserDEALLOCATE, PostgreSQLParserDECLARE, PostgreSQLParserDEFAULTS, PostgreSQLParserDEFERRED, PostgreSQLParserDEFINER, PostgreSQLParserDELETE_P, PostgreSQLParserDELIMITER, PostgreSQLParserDELIMITERS, PostgreSQLParserDICTIONARY, PostgreSQLParserDISABLE_P, PostgreSQLParserDISCARD, PostgreSQLParserDOCUMENT_P, PostgreSQLParserDOMAIN_P, PostgreSQLParserDOUBLE_P, PostgreSQLParserDROP, PostgreSQLParserEACH, PostgreSQLParserENABLE_P, PostgreSQLParserENCODING, PostgreSQLParserENCRYPTED, PostgreSQLParserENUM_P, PostgreSQLParserESCAPE, PostgreSQLParserEVENT, PostgreSQLParserEXCLUDE, PostgreSQLParserEXCLUDING, PostgreSQLParserEXCLUSIVE, PostgreSQLParserEXECUTE, PostgreSQLParserEXPLAIN, PostgreSQLParserEXTENSION, PostgreSQLParserEXTERNAL, PostgreSQLParserFAMILY, PostgreSQLParserFIRST_P, PostgreSQLParserFOLLOWING, PostgreSQLParserFORCE, PostgreSQLParserFORWARD, PostgreSQLParserFUNCTION, PostgreSQLParserFUNCTIONS, PostgreSQLParserGLOBAL, PostgreSQLParserGRANTED, PostgreSQLParserHANDLER, PostgreSQLParserHEADER_P, PostgreSQLParserHOLD, PostgreSQLParserHOUR_P, PostgreSQLParserIDENTITY_P, PostgreSQLParserIF_P, PostgreSQLParserIMMEDIATE, PostgreSQLParserIMMUTABLE, PostgreSQLParserIMPLICIT_P, PostgreSQLParserINCLUDING, PostgreSQLParserINCREMENT, PostgreSQLParserINDEX, PostgreSQLParserINDEXES, PostgreSQLParserINHERIT, PostgreSQLParserINHERITS, PostgreSQLParserINLINE_P, PostgreSQLParserINSENSITIVE, PostgreSQLParserINSERT, PostgreSQLParserINSTEAD, PostgreSQLParserINVOKER, PostgreSQLParserISOLATION, PostgreSQLParserKEY, PostgreSQLParserLABEL, PostgreSQLParserLANGUAGE, PostgreSQLParserLARGE_P, PostgreSQLParserLAST_P, PostgreSQLParserLEAKPROOF, PostgreSQLParserLEVEL, PostgreSQLParserLISTEN, PostgreSQLParserLOAD, PostgreSQLParserLOCAL, PostgreSQLParserLOCATION, PostgreSQLParserLOCK_P, PostgreSQLParserMAPPING, PostgreSQLParserMATCH, PostgreSQLParserMATERIALIZED, PostgreSQLParserMAXVALUE, PostgreSQLParserMINUTE_P, PostgreSQLParserMINVALUE, PostgreSQLParserMODE, PostgreSQLParserMONTH_P, PostgreSQLParserMOVE, PostgreSQLParserNAME_P, PostgreSQLParserNAMES, PostgreSQLParserNEXT, PostgreSQLParserNO, PostgreSQLParserNOTHING, PostgreSQLParserNOTIFY, PostgreSQLParserNOWAIT, PostgreSQLParserNULLS_P, PostgreSQLParserOBJECT_P, PostgreSQLParserOF, PostgreSQLParserOFF, PostgreSQLParserOIDS, PostgreSQLParserOPERATOR, PostgreSQLParserOPTION, PostgreSQLParserOPTIONS, PostgreSQLParserOWNED, PostgreSQLParserOWNER, PostgreSQLParserPARSER, PostgreSQLParserPARTIAL, PostgreSQLParserPARTITION, PostgreSQLParserPASSING, PostgreSQLParserPASSWORD, PostgreSQLParserPLANS, PostgreSQLParserPRECEDING, PostgreSQLParserPREPARE, PostgreSQLParserPREPARED, PostgreSQLParserPRESERVE, PostgreSQLParserPRIOR, PostgreSQLParserPRIVILEGES, PostgreSQLParserPROCEDURAL, PostgreSQLParserPROCEDURE, PostgreSQLParserPROGRAM, PostgreSQLParserQUOTE, PostgreSQLParserRANGE, PostgreSQLParserREAD, PostgreSQLParserREASSIGN, PostgreSQLParserRECHECK, PostgreSQLParserRECURSIVE, PostgreSQLParserREF, PostgreSQLParserREFRESH, PostgreSQLParserREINDEX, PostgreSQLParserRELATIVE_P, PostgreSQLParserRELEASE, PostgreSQLParserRENAME, PostgreSQLParserREPEATABLE, PostgreSQLParserREPLACE, PostgreSQLParserREPLICA, PostgreSQLParserRESET, PostgreSQLParserRESTART, PostgreSQLParserRESTRICT, PostgreSQLParserRETURNS, PostgreSQLParserREVOKE, PostgreSQLParserROLE, PostgreSQLParserROLLBACK, PostgreSQLParserROWS, PostgreSQLParserRULE, PostgreSQLParserSAVEPOINT, PostgreSQLParserSCHEMA, PostgreSQLParserSCROLL, PostgreSQLParserSEARCH, PostgreSQLParserSECOND_P, PostgreSQLParserSECURITY, PostgreSQLParserSEQUENCE, PostgreSQLParserSEQUENCES, PostgreSQLParserSERIALIZABLE, PostgreSQLParserSERVER, PostgreSQLParserSESSION, PostgreSQLParserSET, PostgreSQLParserSHARE, PostgreSQLParserSHOW, PostgreSQLParserSIMPLE, PostgreSQLParserSNAPSHOT, PostgreSQLParserSTABLE, PostgreSQLParserSTANDALONE_P, PostgreSQLParserSTART, PostgreSQLParserSTATEMENT, PostgreSQLParserSTATISTICS, PostgreSQLParserSTDIN, PostgreSQLParserSTDOUT, PostgreSQLParserSTORAGE, PostgreSQLParserSTRICT_P, PostgreSQLParserSTRIP_P, PostgreSQLParserSYSID, PostgreSQLParserSYSTEM_P, PostgreSQLParserTABLES, PostgreSQLParserTABLESPACE, PostgreSQLParserTEMP, PostgreSQLParserTEMPLATE, PostgreSQLParserTEMPORARY, PostgreSQLParserTEXT_P, PostgreSQLParserTRANSACTION, PostgreSQLParserTRIGGER, PostgreSQLParserTRUNCATE, PostgreSQLParserTRUSTED, PostgreSQLParserTYPE_P, PostgreSQLParserTYPES_P, PostgreSQLParserUNBOUNDED, PostgreSQLParserUNCOMMITTED, PostgreSQLParserUNENCRYPTED, PostgreSQLParserUNKNOWN, PostgreSQLParserUNLISTEN, PostgreSQLParserUNLOGGED, PostgreSQLParserUNTIL, PostgreSQLParserUPDATE, PostgreSQLParserVACUUM, PostgreSQLParserVALID, PostgreSQLParserVALIDATE, PostgreSQLParserVALIDATOR, PostgreSQLParserVARYING, PostgreSQLParserVERSION_P, PostgreSQLParserVIEW, PostgreSQLParserVOLATILE, PostgreSQLParserWHITESPACE_P, PostgreSQLParserWITHOUT, PostgreSQLParserWORK, PostgreSQLParserWRAPPER, PostgreSQLParserWRITE, PostgreSQLParserXML_P, PostgreSQLParserYEAR_P, PostgreSQLParserYES_P, PostgreSQLParserZONE, PostgreSQLParserBETWEEN, PostgreSQLParserBIGINT, PostgreSQLParserBIT, PostgreSQLParserBOOLEAN_P, PostgreSQLParserCHAR_P, PostgreSQLParserCHARACTER, PostgreSQLParserCOALESCE, PostgreSQLParserDEC, PostgreSQLParserDECIMAL_P, PostgreSQLParserEXISTS, PostgreSQLParserEXTRACT, PostgreSQLParserFLOAT_P, PostgreSQLParserGREATEST, PostgreSQLParserINOUT, PostgreSQLParserINT_P, PostgreSQLParserINTEGER, PostgreSQLParserINTERVAL, PostgreSQLParserLEAST, PostgreSQLParserNATIONAL, PostgreSQLParserNCHAR, PostgreSQLParserNONE, PostgreSQLParserNULLIF, PostgreSQLParserNUMERIC, PostgreSQLParserOVERLAY, PostgreSQLParserPOSITION, PostgreSQLParserPRECISION, PostgreSQLParserREAL, PostgreSQLParserROW, PostgreSQLParserSETOF, PostgreSQLParserSMALLINT, PostgreSQLParserSUBSTRING, PostgreSQLParserTIME, PostgreSQLParserTIMESTAMP, PostgreSQLParserTREAT, PostgreSQLParserTRIM, PostgreSQLParserVALUES, PostgreSQLParserVARCHAR, PostgreSQLParserXMLATTRIBUTES, PostgreSQLParserXMLCOMMENT, PostgreSQLParserXMLAGG, PostgreSQLParserXML_IS_WELL_FORMED, PostgreSQLParserXML_IS_WELL_FORMED_DOCUMENT, PostgreSQLParserXML_IS_WELL_FORMED_CONTENT, PostgreSQLParserXPATH, PostgreSQLParserXPATH_EXISTS, PostgreSQLParserXMLCONCAT, PostgreSQLParserXMLELEMENT, PostgreSQLParserXMLEXISTS, PostgreSQLParserXMLFOREST, PostgreSQLParserXMLPARSE, PostgreSQLParserXMLPI, PostgreSQLParserXMLROOT, PostgreSQLParserXMLSERIALIZE, PostgreSQLParserCALL, PostgreSQLParserCURRENT_P, PostgreSQLParserATTACH, PostgreSQLParserDETACH, PostgreSQLParserEXPRESSION, PostgreSQLParserGENERATED, PostgreSQLParserLOGGED, PostgreSQLParserSTORED, PostgreSQLParserINCLUDE, PostgreSQLParserROUTINE, PostgreSQLParserTRANSFORM, PostgreSQLParserIMPORT_P, PostgreSQLParserPOLICY, PostgreSQLParserMETHOD, PostgreSQLParserREFERENCING, PostgreSQLParserNEW, PostgreSQLParserOLD, PostgreSQLParserVALUE_P, PostgreSQLParserSUBSCRIPTION, PostgreSQLParserPUBLICATION, PostgreSQLParserOUT_P, PostgreSQLParserROUTINES, PostgreSQLParserSCHEMAS, PostgreSQLParserPROCEDURES, PostgreSQLParserINPUT_P, PostgreSQLParserSUPPORT, PostgreSQLParserPARALLEL, PostgreSQLParserSQL_P, PostgreSQLParserDEPENDS, PostgreSQLParserOVERRIDING, PostgreSQLParserCONFLICT, PostgreSQLParserSKIP_P, PostgreSQLParserLOCKED, PostgreSQLParserTIES, PostgreSQLParserROLLUP, PostgreSQLParserCUBE, PostgreSQLParserGROUPING, PostgreSQLParserSETS, PostgreSQLParserTABLESAMPLE, PostgreSQLParserORDINALITY, PostgreSQLParserXMLTABLE, PostgreSQLParserCOLUMNS, PostgreSQLParserXMLNAMESPACES, PostgreSQLParserROWTYPE, PostgreSQLParserNORMALIZED, PostgreSQLParserWITHIN, PostgreSQLParserFILTER, PostgreSQLParserGROUPS, PostgreSQLParserOTHERS, PostgreSQLParserNFC, PostgreSQLParserNFD, PostgreSQLParserNFKC, PostgreSQLParserNFKD, PostgreSQLParserUESCAPE, PostgreSQLParserVIEWS, PostgreSQLParserNORMALIZE, PostgreSQLParserDUMP, PostgreSQLParserPRINT_STRICT_PARAMS, PostgreSQLParserVARIABLE_CONFLICT, PostgreSQLParserERROR, PostgreSQLParserUSE_VARIABLE, PostgreSQLParserUSE_COLUMN, PostgreSQLParserALIAS, PostgreSQLParserCONSTANT, PostgreSQLParserPERFORM, PostgreSQLParserGET, PostgreSQLParserDIAGNOSTICS, PostgreSQLParserSTACKED, PostgreSQLParserELSIF, PostgreSQLParserREVERSE, PostgreSQLParserSLICE, PostgreSQLParserEXIT, PostgreSQLParserRETURN, PostgreSQLParserQUERY, PostgreSQLParserRAISE, PostgreSQLParserSQLSTATE, PostgreSQLParserDEBUG, PostgreSQLParserLOG, PostgreSQLParserINFO, PostgreSQLParserNOTICE, PostgreSQLParserWARNING, PostgreSQLParserEXCEPTION, PostgreSQLParserASSERT, PostgreSQLParserOPEN, PostgreSQLParserABS, PostgreSQLParserCBRT, PostgreSQLParserCEIL, PostgreSQLParserCEILING, PostgreSQLParserDEGREES, PostgreSQLParserDIV, PostgreSQLParserEXP, PostgreSQLParserFACTORIAL, PostgreSQLParserFLOOR, PostgreSQLParserGCD, PostgreSQLParserLCM, PostgreSQLParserLN, PostgreSQLParserLOG10, PostgreSQLParserMIN_SCALE, PostgreSQLParserMOD, PostgreSQLParserPI, PostgreSQLParserPOWER, PostgreSQLParserRADIANS, PostgreSQLParserROUND, PostgreSQLParserSCALE, PostgreSQLParserSIGN, PostgreSQLParserSQRT, PostgreSQLParserTRIM_SCALE, PostgreSQLParserTRUNC, PostgreSQLParserWIDTH_BUCKET, PostgreSQLParserRANDOM, PostgreSQLParserSETSEED, PostgreSQLParserACOS, PostgreSQLParserACOSD, PostgreSQLParserASIN, PostgreSQLParserASIND, PostgreSQLParserATAN, PostgreSQLParserATAND, PostgreSQLParserATAN2, PostgreSQLParserATAN2D, PostgreSQLParserCOS, PostgreSQLParserCOSD, PostgreSQLParserCOT, PostgreSQLParserCOTD, PostgreSQLParserSIN, PostgreSQLParserSIND, PostgreSQLParserTAN, PostgreSQLParserTAND, PostgreSQLParserSINH, PostgreSQLParserCOSH, PostgreSQLParserTANH, PostgreSQLParserASINH, PostgreSQLParserACOSH, PostgreSQLParserATANH, PostgreSQLParserBIT_LENGTH, PostgreSQLParserCHAR_LENGTH, PostgreSQLParserCHARACTER_LENGTH, PostgreSQLParserLOWER, PostgreSQLParserOCTET_LENGTH, PostgreSQLParserUPPER, PostgreSQLParserASCII, PostgreSQLParserBTRIM, PostgreSQLParserCHR, PostgreSQLParserCONCAT, PostgreSQLParserCONCAT_WS, PostgreSQLParserFORMAT, PostgreSQLParserINITCAP, PostgreSQLParserLENGTH, PostgreSQLParserLPAD, PostgreSQLParserLTRIM, PostgreSQLParserMD5, PostgreSQLParserPARSE_IDENT, PostgreSQLParserPG_CLIENT_ENCODING, PostgreSQLParserQUOTE_IDENT, PostgreSQLParserQUOTE_LITERAL, PostgreSQLParserQUOTE_NULLABLE, PostgreSQLParserREGEXP_COUNT, PostgreSQLParserREGEXP_INSTR, PostgreSQLParserREGEXP_LIKE, PostgreSQLParserREGEXP_MATCH, PostgreSQLParserREGEXP_MATCHES, PostgreSQLParserREGEXP_REPLACE, PostgreSQLParserREGEXP_SPLIT_TO_ARRAY, PostgreSQLParserREGEXP_SPLIT_TO_TABLE, PostgreSQLParserREGEXP_SUBSTR, PostgreSQLParserREPEAT, PostgreSQLParserRPAD, PostgreSQLParserRTRIM, PostgreSQLParserSPLIT_PART, PostgreSQLParserSTARTS_WITH, PostgreSQLParserSTRING_TO_ARRAY, PostgreSQLParserSTRING_TO_TABLE, PostgreSQLParserSTRPOS, PostgreSQLParserSUBSTR, PostgreSQLParserTO_ASCII, PostgreSQLParserTO_HEX, PostgreSQLParserTRANSLATE, PostgreSQLParserUNISTR, PostgreSQLParserAGE, PostgreSQLParserCLOCK_TIMESTAMP, PostgreSQLParserDATE_BIN, PostgreSQLParserDATE_PART, PostgreSQLParserDATE_TRUNC, PostgreSQLParserISFINITE, PostgreSQLParserJUSTIFY_DAYS, PostgreSQLParserJUSTIFY_HOURS, PostgreSQLParserJUSTIFY_INTERVAL, PostgreSQLParserMAKE_DATE, PostgreSQLParserMAKE_INTERVAL, PostgreSQLParserMAKE_TIME, PostgreSQLParserMAKE_TIMESTAMP, PostgreSQLParserMAKE_TIMESTAMPTZ, PostgreSQLParserNOW, PostgreSQLParserSTATEMENT_TIMESTAMP, PostgreSQLParserTIMEOFDAY, PostgreSQLParserTRANSACTION_TIMESTAMP, PostgreSQLParserTO_TIMESTAMP, PostgreSQLParserTO_CHAR, PostgreSQLParserTO_DATE, PostgreSQLParserTO_NUMBER, PostgreSQLParserIdentifier, PostgreSQLParserQuotedIdentifier, PostgreSQLParserUnicodeQuotedIdentifier, PostgreSQLParserStringConstant, PostgreSQLParserUnicodeEscapeStringConstant, PostgreSQLParserBeginDollarStringConstant, PostgreSQLParserPLSQLVARIABLENAME, PostgreSQLParserPLSQLIDENTIFIER, PostgreSQLParserEscapeStringConstant:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(7501)
			p.Opt_boolean_or_string()
		}

	case PostgreSQLParserPLUS, PostgreSQLParserMINUS, PostgreSQLParserIntegral, PostgreSQLParserNumeric:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(7502)
			p.Numericonly()
		}

	case PostgreSQLParserCLOSE_PAREN, PostgreSQLParserCOMMA:
		p.EnterOuterAlt(localctx, 3)

	default:
		p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IOpt_analyzeContext is an interface to support dynamic dispatch.
type IOpt_analyzeContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Analyze_keyword() IAnalyze_keywordContext

	// IsOpt_analyzeContext differentiates from other interfaces.
	IsOpt_analyzeContext()
}

type Opt_analyzeContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyOpt_analyzeContext() *Opt_analyzeContext {
	var p = new(Opt_analyzeContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opt_analyze
	return p
}

func InitEmptyOpt_analyzeContext(p *Opt_analyzeContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opt_analyze
}

func (*Opt_analyzeContext) IsOpt_analyzeContext() {}

func NewOpt_analyzeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_analyzeContext {
	var p = new(Opt_analyzeContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_opt_analyze

	return p
}

func (s *Opt_analyzeContext) GetParser() antlr.Parser { return s.parser }

func (s *Opt_analyzeContext) Analyze_keyword() IAnalyze_keywordContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IAnalyze_keywordContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IAnalyze_keywordContext)
}

func (s *Opt_analyzeContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Opt_analyzeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Opt_analyzeContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterOpt_analyze(s)
	}
}

func (s *Opt_analyzeContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitOpt_analyze(s)
	}
}

func (s *Opt_analyzeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitOpt_analyze(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Opt_analyze() (localctx IOpt_analyzeContext) {
	localctx = NewOpt_analyzeContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 862, PostgreSQLParserRULE_opt_analyze)
	p.SetState(7508)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 365, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(7506)
			p.Analyze_keyword()
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)

	case antlr.ATNInvalidAltNumber:
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IOpt_verboseContext is an interface to support dynamic dispatch.
type IOpt_verboseContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	VERBOSE() antlr.TerminalNode

	// IsOpt_verboseContext differentiates from other interfaces.
	IsOpt_verboseContext()
}

type Opt_verboseContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyOpt_verboseContext() *Opt_verboseContext {
	var p = new(Opt_verboseContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opt_verbose
	return p
}

func InitEmptyOpt_verboseContext(p *Opt_verboseContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opt_verbose
}

func (*Opt_verboseContext) IsOpt_verboseContext() {}

func NewOpt_verboseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_verboseContext {
	var p = new(Opt_verboseContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_opt_verbose

	return p
}

func (s *Opt_verboseContext) GetParser() antlr.Parser { return s.parser }

func (s *Opt_verboseContext) VERBOSE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserVERBOSE, 0)
}

func (s *Opt_verboseContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Opt_verboseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Opt_verboseContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterOpt_verbose(s)
	}
}

func (s *Opt_verboseContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitOpt_verbose(s)
	}
}

func (s *Opt_verboseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitOpt_verbose(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Opt_verbose() (localctx IOpt_verboseContext) {
	localctx = NewOpt_verboseContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 864, PostgreSQLParserRULE_opt_verbose)
	p.SetState(7512)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetTokenStream().LA(1) {
	case PostgreSQLParserVERBOSE:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(7510)
			p.Match(PostgreSQLParserVERBOSE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case PostgreSQLParserEOF, PostgreSQLParserOPEN_PAREN, PostgreSQLParserSEMI, PostgreSQLParserANALYSE, PostgreSQLParserANALYZE, PostgreSQLParserAND, PostgreSQLParserARRAY, PostgreSQLParserCOLLATE, PostgreSQLParserCOLUMN, PostgreSQLParserCONSTRAINT, PostgreSQLParserCREATE, PostgreSQLParserDEFAULT, PostgreSQLParserDO, PostgreSQLParserFETCH, PostgreSQLParserGRANT, PostgreSQLParserINTO, PostgreSQLParserSELECT, PostgreSQLParserTABLE, PostgreSQLParserWITH, PostgreSQLParserIS, PostgreSQLParserLEFT, PostgreSQLParserOUTER_P, PostgreSQLParserOVER, PostgreSQLParserRIGHT, PostgreSQLParserABORT_P, PostgreSQLParserABSOLUTE_P, PostgreSQLParserACCESS, PostgreSQLParserACTION, PostgreSQLParserADD_P, PostgreSQLParserADMIN, PostgreSQLParserAFTER, PostgreSQLParserAGGREGATE, PostgreSQLParserALSO, PostgreSQLParserALTER, PostgreSQLParserALWAYS, PostgreSQLParserASSERTION, PostgreSQLParserASSIGNMENT, PostgreSQLParserAT, PostgreSQLParserATTRIBUTE, PostgreSQLParserBACKWARD, PostgreSQLParserBEFORE, PostgreSQLParserBEGIN_P, PostgreSQLParserBY, PostgreSQLParserCACHE, PostgreSQLParserCALLED, PostgreSQLParserCASCADE, PostgreSQLParserCASCADED, PostgreSQLParserCATALOG, PostgreSQLParserCHAIN, PostgreSQLParserCHARACTERISTICS, PostgreSQLParserCHECKPOINT, PostgreSQLParserCLASS, PostgreSQLParserCLOSE, PostgreSQLParserCLUSTER, PostgreSQLParserCOMMENT, PostgreSQLParserCOMMENTS, PostgreSQLParserCOMMIT, PostgreSQLParserCOMMITTED, PostgreSQLParserCONFIGURATION, PostgreSQLParserCONNECTION, PostgreSQLParserCONSTRAINTS, PostgreSQLParserCONTENT_P, PostgreSQLParserCONTINUE_P, PostgreSQLParserCONVERSION_P, PostgreSQLParserCOPY, PostgreSQLParserCOST, PostgreSQLParserCSV, PostgreSQLParserCURSOR, PostgreSQLParserCYCLE, PostgreSQLParserDATA_P, PostgreSQLParserDATABASE, PostgreSQLParserDAY_P, PostgreSQLParserDEALLOCATE, PostgreSQLParserDECLARE, PostgreSQLParserDEFAULTS, PostgreSQLParserDEFERRED, PostgreSQLParserDEFINER, PostgreSQLParserDELETE_P, PostgreSQLParserDELIMITER, PostgreSQLParserDELIMITERS, PostgreSQLParserDICTIONARY, PostgreSQLParserDISABLE_P, PostgreSQLParserDISCARD, PostgreSQLParserDOCUMENT_P, PostgreSQLParserDOMAIN_P, PostgreSQLParserDOUBLE_P, PostgreSQLParserDROP, PostgreSQLParserEACH, PostgreSQLParserENABLE_P, PostgreSQLParserENCODING, PostgreSQLParserENCRYPTED, PostgreSQLParserENUM_P, PostgreSQLParserESCAPE, PostgreSQLParserEVENT, PostgreSQLParserEXCLUDE, PostgreSQLParserEXCLUDING, PostgreSQLParserEXCLUSIVE, PostgreSQLParserEXECUTE, PostgreSQLParserEXPLAIN, PostgreSQLParserEXTENSION, PostgreSQLParserEXTERNAL, PostgreSQLParserFAMILY, PostgreSQLParserFIRST_P, PostgreSQLParserFOLLOWING, PostgreSQLParserFORCE, PostgreSQLParserFORWARD, PostgreSQLParserFUNCTION, PostgreSQLParserFUNCTIONS, PostgreSQLParserGLOBAL, PostgreSQLParserGRANTED, PostgreSQLParserHANDLER, PostgreSQLParserHEADER_P, PostgreSQLParserHOLD, PostgreSQLParserHOUR_P, PostgreSQLParserIDENTITY_P, PostgreSQLParserIF_P, PostgreSQLParserIMMEDIATE, PostgreSQLParserIMMUTABLE, PostgreSQLParserIMPLICIT_P, PostgreSQLParserINCLUDING, PostgreSQLParserINCREMENT, PostgreSQLParserINDEX, PostgreSQLParserINDEXES, PostgreSQLParserINHERIT, PostgreSQLParserINHERITS, PostgreSQLParserINLINE_P, PostgreSQLParserINSENSITIVE, PostgreSQLParserINSERT, PostgreSQLParserINSTEAD, PostgreSQLParserINVOKER, PostgreSQLParserISOLATION, PostgreSQLParserKEY, PostgreSQLParserLABEL, PostgreSQLParserLANGUAGE, PostgreSQLParserLARGE_P, PostgreSQLParserLAST_P, PostgreSQLParserLEAKPROOF, PostgreSQLParserLEVEL, PostgreSQLParserLISTEN, PostgreSQLParserLOAD, PostgreSQLParserLOCAL, PostgreSQLParserLOCATION, PostgreSQLParserLOCK_P, PostgreSQLParserMAPPING, PostgreSQLParserMATCH, PostgreSQLParserMATERIALIZED, PostgreSQLParserMAXVALUE, PostgreSQLParserMERGE, PostgreSQLParserMINUTE_P, PostgreSQLParserMINVALUE, PostgreSQLParserMODE, PostgreSQLParserMONTH_P, PostgreSQLParserMOVE, PostgreSQLParserNAME_P, PostgreSQLParserNAMES, PostgreSQLParserNEXT, PostgreSQLParserNO, PostgreSQLParserNOTHING, PostgreSQLParserNOTIFY, PostgreSQLParserNOWAIT, PostgreSQLParserNULLS_P, PostgreSQLParserOBJECT_P, PostgreSQLParserOF, PostgreSQLParserOFF, PostgreSQLParserOIDS, PostgreSQLParserOPERATOR, PostgreSQLParserOPTION, PostgreSQLParserOPTIONS, PostgreSQLParserOWNED, PostgreSQLParserOWNER, PostgreSQLParserPARSER, PostgreSQLParserPARTIAL, PostgreSQLParserPARTITION, PostgreSQLParserPASSING, PostgreSQLParserPASSWORD, PostgreSQLParserPLANS, PostgreSQLParserPRECEDING, PostgreSQLParserPREPARE, PostgreSQLParserPREPARED, PostgreSQLParserPRESERVE, PostgreSQLParserPRIOR, PostgreSQLParserPRIVILEGES, PostgreSQLParserPROCEDURAL, PostgreSQLParserPROCEDURE, PostgreSQLParserPROGRAM, PostgreSQLParserQUOTE, PostgreSQLParserRANGE, PostgreSQLParserREAD, PostgreSQLParserREASSIGN, PostgreSQLParserRECHECK, PostgreSQLParserRECURSIVE, PostgreSQLParserREF, PostgreSQLParserREFRESH, PostgreSQLParserREINDEX, PostgreSQLParserRELATIVE_P, PostgreSQLParserRELEASE, PostgreSQLParserRENAME, PostgreSQLParserREPEATABLE, PostgreSQLParserREPLACE, PostgreSQLParserREPLICA, PostgreSQLParserRESET, PostgreSQLParserRESTART, PostgreSQLParserRESTRICT, PostgreSQLParserRETURNS, PostgreSQLParserREVOKE, PostgreSQLParserROLE, PostgreSQLParserROLLBACK, PostgreSQLParserROWS, PostgreSQLParserRULE, PostgreSQLParserSAVEPOINT, PostgreSQLParserSCHEMA, PostgreSQLParserSCROLL, PostgreSQLParserSEARCH, PostgreSQLParserSECOND_P, PostgreSQLParserSECURITY, PostgreSQLParserSEQUENCE, PostgreSQLParserSEQUENCES, PostgreSQLParserSERIALIZABLE, PostgreSQLParserSERVER, PostgreSQLParserSESSION, PostgreSQLParserSET, PostgreSQLParserSHARE, PostgreSQLParserSHOW, PostgreSQLParserSIMPLE, PostgreSQLParserSNAPSHOT, PostgreSQLParserSTABLE, PostgreSQLParserSTANDALONE_P, PostgreSQLParserSTART, PostgreSQLParserSTATEMENT, PostgreSQLParserSTATISTICS, PostgreSQLParserSTDIN, PostgreSQLParserSTDOUT, PostgreSQLParserSTORAGE, PostgreSQLParserSTRICT_P, PostgreSQLParserSTRIP_P, PostgreSQLParserSYSID, PostgreSQLParserSYSTEM_P, PostgreSQLParserTABLES, PostgreSQLParserTABLESPACE, PostgreSQLParserTEMP, PostgreSQLParserTEMPLATE, PostgreSQLParserTEMPORARY, PostgreSQLParserTEXT_P, PostgreSQLParserTRANSACTION, PostgreSQLParserTRIGGER, PostgreSQLParserTRUNCATE, PostgreSQLParserTRUSTED, PostgreSQLParserTYPE_P, PostgreSQLParserTYPES_P, PostgreSQLParserUNBOUNDED, PostgreSQLParserUNCOMMITTED, PostgreSQLParserUNENCRYPTED, PostgreSQLParserUNKNOWN, PostgreSQLParserUNLISTEN, PostgreSQLParserUNLOGGED, PostgreSQLParserUNTIL, PostgreSQLParserUPDATE, PostgreSQLParserVACUUM, PostgreSQLParserVALID, PostgreSQLParserVALIDATE, PostgreSQLParserVALIDATOR, PostgreSQLParserVARYING, PostgreSQLParserVERSION_P, PostgreSQLParserVIEW, PostgreSQLParserVOLATILE, PostgreSQLParserWHITESPACE_P, PostgreSQLParserWITHOUT, PostgreSQLParserWORK, PostgreSQLParserWRAPPER, PostgreSQLParserWRITE, PostgreSQLParserXML_P, PostgreSQLParserYEAR_P, PostgreSQLParserYES_P, PostgreSQLParserZONE, PostgreSQLParserBETWEEN, PostgreSQLParserBIGINT, PostgreSQLParserBIT, PostgreSQLParserBOOLEAN_P, PostgreSQLParserCHAR_P, PostgreSQLParserCHARACTER, PostgreSQLParserCOALESCE, PostgreSQLParserDEC, PostgreSQLParserDECIMAL_P, PostgreSQLParserEXISTS, PostgreSQLParserEXTRACT, PostgreSQLParserFLOAT_P, PostgreSQLParserGREATEST, PostgreSQLParserINOUT, PostgreSQLParserINT_P, PostgreSQLParserINTEGER, PostgreSQLParserINTERVAL, PostgreSQLParserLEAST, PostgreSQLParserNATIONAL, PostgreSQLParserNCHAR, PostgreSQLParserNONE, PostgreSQLParserNULLIF, PostgreSQLParserNUMERIC, PostgreSQLParserOVERLAY, PostgreSQLParserPOSITION, PostgreSQLParserPRECISION, PostgreSQLParserREAL, PostgreSQLParserROW, PostgreSQLParserSETOF, PostgreSQLParserSMALLINT, PostgreSQLParserSUBSTRING, PostgreSQLParserTIME, PostgreSQLParserTIMESTAMP, PostgreSQLParserTREAT, PostgreSQLParserTRIM, PostgreSQLParserVALUES, PostgreSQLParserVARCHAR, PostgreSQLParserXMLATTRIBUTES, PostgreSQLParserXMLCOMMENT, PostgreSQLParserXMLAGG, PostgreSQLParserXML_IS_WELL_FORMED, PostgreSQLParserXML_IS_WELL_FORMED_DOCUMENT, PostgreSQLParserXML_IS_WELL_FORMED_CONTENT, PostgreSQLParserXPATH, PostgreSQLParserXPATH_EXISTS, PostgreSQLParserXMLCONCAT, PostgreSQLParserXMLELEMENT, PostgreSQLParserXMLEXISTS, PostgreSQLParserXMLFOREST, PostgreSQLParserXMLPARSE, PostgreSQLParserXMLPI, PostgreSQLParserXMLROOT, PostgreSQLParserXMLSERIALIZE, PostgreSQLParserCALL, PostgreSQLParserCURRENT_P, PostgreSQLParserATTACH, PostgreSQLParserDETACH, PostgreSQLParserEXPRESSION, PostgreSQLParserGENERATED, PostgreSQLParserLOGGED, PostgreSQLParserSTORED, PostgreSQLParserINCLUDE, PostgreSQLParserROUTINE, PostgreSQLParserTRANSFORM, PostgreSQLParserIMPORT_P, PostgreSQLParserPOLICY, PostgreSQLParserMETHOD, PostgreSQLParserREFERENCING, PostgreSQLParserNEW, PostgreSQLParserOLD, PostgreSQLParserVALUE_P, PostgreSQLParserSUBSCRIPTION, PostgreSQLParserPUBLICATION, PostgreSQLParserOUT_P, PostgreSQLParserEND_P, PostgreSQLParserROUTINES, PostgreSQLParserSCHEMAS, PostgreSQLParserPROCEDURES, PostgreSQLParserINPUT_P, PostgreSQLParserSUPPORT, PostgreSQLParserPARALLEL, PostgreSQLParserSQL_P, PostgreSQLParserDEPENDS, PostgreSQLParserOVERRIDING, PostgreSQLParserCONFLICT, PostgreSQLParserSKIP_P, PostgreSQLParserLOCKED, PostgreSQLParserTIES, PostgreSQLParserROLLUP, PostgreSQLParserCUBE, PostgreSQLParserGROUPING, PostgreSQLParserSETS, PostgreSQLParserORDINALITY, PostgreSQLParserXMLTABLE, PostgreSQLParserCOLUMNS, PostgreSQLParserXMLNAMESPACES, PostgreSQLParserROWTYPE, PostgreSQLParserNORMALIZED, PostgreSQLParserWITHIN, PostgreSQLParserFILTER, PostgreSQLParserGROUPS, PostgreSQLParserOTHERS, PostgreSQLParserNFC, PostgreSQLParserNFD, PostgreSQLParserNFKC, PostgreSQLParserNFKD, PostgreSQLParserUESCAPE, PostgreSQLParserVIEWS, PostgreSQLParserNORMALIZE, PostgreSQLParserDUMP, PostgreSQLParserPRINT_STRICT_PARAMS, PostgreSQLParserVARIABLE_CONFLICT, PostgreSQLParserERROR, PostgreSQLParserUSE_VARIABLE, PostgreSQLParserUSE_COLUMN, PostgreSQLParserALIAS, PostgreSQLParserCONSTANT, PostgreSQLParserPERFORM, PostgreSQLParserGET, PostgreSQLParserDIAGNOSTICS, PostgreSQLParserSTACKED, PostgreSQLParserELSIF, PostgreSQLParserREVERSE, PostgreSQLParserSLICE, PostgreSQLParserEXIT, PostgreSQLParserRETURN, PostgreSQLParserQUERY, PostgreSQLParserRAISE, PostgreSQLParserSQLSTATE, PostgreSQLParserDEBUG, PostgreSQLParserLOG, PostgreSQLParserINFO, PostgreSQLParserNOTICE, PostgreSQLParserWARNING, PostgreSQLParserEXCEPTION, PostgreSQLParserASSERT, PostgreSQLParserOPEN, PostgreSQLParserABS, PostgreSQLParserCBRT, PostgreSQLParserCEIL, PostgreSQLParserCEILING, PostgreSQLParserDEGREES, PostgreSQLParserDIV, PostgreSQLParserEXP, PostgreSQLParserFACTORIAL, PostgreSQLParserFLOOR, PostgreSQLParserGCD, PostgreSQLParserLCM, PostgreSQLParserLN, PostgreSQLParserLOG10, PostgreSQLParserMIN_SCALE, PostgreSQLParserMOD, PostgreSQLParserPI, PostgreSQLParserPOWER, PostgreSQLParserRADIANS, PostgreSQLParserROUND, PostgreSQLParserSCALE, PostgreSQLParserSIGN, PostgreSQLParserSQRT, PostgreSQLParserTRIM_SCALE, PostgreSQLParserTRUNC, PostgreSQLParserWIDTH_BUCKET, PostgreSQLParserRANDOM, PostgreSQLParserSETSEED, PostgreSQLParserACOS, PostgreSQLParserACOSD, PostgreSQLParserASIN, PostgreSQLParserASIND, PostgreSQLParserATAN, PostgreSQLParserATAND, PostgreSQLParserATAN2, PostgreSQLParserATAN2D, PostgreSQLParserCOS, PostgreSQLParserCOSD, PostgreSQLParserCOT, PostgreSQLParserCOTD, PostgreSQLParserSIN, PostgreSQLParserSIND, PostgreSQLParserTAN, PostgreSQLParserTAND, PostgreSQLParserSINH, PostgreSQLParserCOSH, PostgreSQLParserTANH, PostgreSQLParserASINH, PostgreSQLParserACOSH, PostgreSQLParserATANH, PostgreSQLParserBIT_LENGTH, PostgreSQLParserCHAR_LENGTH, PostgreSQLParserCHARACTER_LENGTH, PostgreSQLParserLOWER, PostgreSQLParserOCTET_LENGTH, PostgreSQLParserUPPER, PostgreSQLParserASCII, PostgreSQLParserBTRIM, PostgreSQLParserCHR, PostgreSQLParserCONCAT, PostgreSQLParserCONCAT_WS, PostgreSQLParserFORMAT, PostgreSQLParserINITCAP, PostgreSQLParserLENGTH, PostgreSQLParserLPAD, PostgreSQLParserLTRIM, PostgreSQLParserMD5, PostgreSQLParserPARSE_IDENT, PostgreSQLParserPG_CLIENT_ENCODING, PostgreSQLParserQUOTE_IDENT, PostgreSQLParserQUOTE_LITERAL, PostgreSQLParserQUOTE_NULLABLE, PostgreSQLParserREGEXP_COUNT, PostgreSQLParserREGEXP_INSTR, PostgreSQLParserREGEXP_LIKE, PostgreSQLParserREGEXP_MATCH, PostgreSQLParserREGEXP_MATCHES, PostgreSQLParserREGEXP_REPLACE, PostgreSQLParserREGEXP_SPLIT_TO_ARRAY, PostgreSQLParserREGEXP_SPLIT_TO_TABLE, PostgreSQLParserREGEXP_SUBSTR, PostgreSQLParserREPEAT, PostgreSQLParserRPAD, PostgreSQLParserRTRIM, PostgreSQLParserSPLIT_PART, PostgreSQLParserSTARTS_WITH, PostgreSQLParserSTRING_TO_ARRAY, PostgreSQLParserSTRING_TO_TABLE, PostgreSQLParserSTRPOS, PostgreSQLParserSUBSTR, PostgreSQLParserTO_ASCII, PostgreSQLParserTO_HEX, PostgreSQLParserTRANSLATE, PostgreSQLParserUNISTR, PostgreSQLParserAGE, PostgreSQLParserCLOCK_TIMESTAMP, PostgreSQLParserDATE_BIN, PostgreSQLParserDATE_PART, PostgreSQLParserDATE_TRUNC, PostgreSQLParserISFINITE, PostgreSQLParserJUSTIFY_DAYS, PostgreSQLParserJUSTIFY_HOURS, PostgreSQLParserJUSTIFY_INTERVAL, PostgreSQLParserMAKE_DATE, PostgreSQLParserMAKE_INTERVAL, PostgreSQLParserMAKE_TIME, PostgreSQLParserMAKE_TIMESTAMP, PostgreSQLParserMAKE_TIMESTAMPTZ, PostgreSQLParserNOW, PostgreSQLParserSTATEMENT_TIMESTAMP, PostgreSQLParserTIMEOFDAY, PostgreSQLParserTRANSACTION_TIMESTAMP, PostgreSQLParserTO_TIMESTAMP, PostgreSQLParserTO_CHAR, PostgreSQLParserTO_DATE, PostgreSQLParserTO_NUMBER, PostgreSQLParserIdentifier, PostgreSQLParserQuotedIdentifier, PostgreSQLParserUnicodeQuotedIdentifier, PostgreSQLParserPLSQLVARIABLENAME, PostgreSQLParserPLSQLIDENTIFIER, PostgreSQLParserMetaCommand:
		p.EnterOuterAlt(localctx, 2)

	default:
		p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IOpt_fullContext is an interface to support dynamic dispatch.
type IOpt_fullContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	FULL() antlr.TerminalNode

	// IsOpt_fullContext differentiates from other interfaces.
	IsOpt_fullContext()
}

type Opt_fullContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyOpt_fullContext() *Opt_fullContext {
	var p = new(Opt_fullContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opt_full
	return p
}

func InitEmptyOpt_fullContext(p *Opt_fullContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opt_full
}

func (*Opt_fullContext) IsOpt_fullContext() {}

func NewOpt_fullContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_fullContext {
	var p = new(Opt_fullContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_opt_full

	return p
}

func (s *Opt_fullContext) GetParser() antlr.Parser { return s.parser }

func (s *Opt_fullContext) FULL() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserFULL, 0)
}

func (s *Opt_fullContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Opt_fullContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Opt_fullContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterOpt_full(s)
	}
}

func (s *Opt_fullContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitOpt_full(s)
	}
}

func (s *Opt_fullContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitOpt_full(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Opt_full() (localctx IOpt_fullContext) {
	localctx = NewOpt_fullContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 866, PostgreSQLParserRULE_opt_full)
	p.SetState(7516)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetTokenStream().LA(1) {
	case PostgreSQLParserFULL:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(7514)
			p.Match(PostgreSQLParserFULL)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case PostgreSQLParserEOF, PostgreSQLParserOPEN_PAREN, PostgreSQLParserSEMI, PostgreSQLParserANALYSE, PostgreSQLParserANALYZE, PostgreSQLParserAND, PostgreSQLParserARRAY, PostgreSQLParserCOLLATE, PostgreSQLParserCOLUMN, PostgreSQLParserCONSTRAINT, PostgreSQLParserCREATE, PostgreSQLParserDEFAULT, PostgreSQLParserDO, PostgreSQLParserFETCH, PostgreSQLParserGRANT, PostgreSQLParserINTO, PostgreSQLParserSELECT, PostgreSQLParserTABLE, PostgreSQLParserWITH, PostgreSQLParserFREEZE, PostgreSQLParserIS, PostgreSQLParserLEFT, PostgreSQLParserOUTER_P, PostgreSQLParserOVER, PostgreSQLParserRIGHT, PostgreSQLParserVERBOSE, PostgreSQLParserABORT_P, PostgreSQLParserABSOLUTE_P, PostgreSQLParserACCESS, PostgreSQLParserACTION, PostgreSQLParserADD_P, PostgreSQLParserADMIN, PostgreSQLParserAFTER, PostgreSQLParserAGGREGATE, PostgreSQLParserALSO, PostgreSQLParserALTER, PostgreSQLParserALWAYS, PostgreSQLParserASSERTION, PostgreSQLParserASSIGNMENT, PostgreSQLParserAT, PostgreSQLParserATTRIBUTE, PostgreSQLParserBACKWARD, PostgreSQLParserBEFORE, PostgreSQLParserBEGIN_P, PostgreSQLParserBY, PostgreSQLParserCACHE, PostgreSQLParserCALLED, PostgreSQLParserCASCADE, PostgreSQLParserCASCADED, PostgreSQLParserCATALOG, PostgreSQLParserCHAIN, PostgreSQLParserCHARACTERISTICS, PostgreSQLParserCHECKPOINT, PostgreSQLParserCLASS, PostgreSQLParserCLOSE, PostgreSQLParserCLUSTER, PostgreSQLParserCOMMENT, PostgreSQLParserCOMMENTS, PostgreSQLParserCOMMIT, PostgreSQLParserCOMMITTED, PostgreSQLParserCONFIGURATION, PostgreSQLParserCONNECTION, PostgreSQLParserCONSTRAINTS, PostgreSQLParserCONTENT_P, PostgreSQLParserCONTINUE_P, PostgreSQLParserCONVERSION_P, PostgreSQLParserCOPY, PostgreSQLParserCOST, PostgreSQLParserCSV, PostgreSQLParserCURSOR, PostgreSQLParserCYCLE, PostgreSQLParserDATA_P, PostgreSQLParserDATABASE, PostgreSQLParserDAY_P, PostgreSQLParserDEALLOCATE, PostgreSQLParserDECLARE, PostgreSQLParserDEFAULTS, PostgreSQLParserDEFERRED, PostgreSQLParserDEFINER, PostgreSQLParserDELETE_P, PostgreSQLParserDELIMITER, PostgreSQLParserDELIMITERS, PostgreSQLParserDICTIONARY, PostgreSQLParserDISABLE_P, PostgreSQLParserDISCARD, PostgreSQLParserDOCUMENT_P, PostgreSQLParserDOMAIN_P, PostgreSQLParserDOUBLE_P, PostgreSQLParserDROP, PostgreSQLParserEACH, PostgreSQLParserENABLE_P, PostgreSQLParserENCODING, PostgreSQLParserENCRYPTED, PostgreSQLParserENUM_P, PostgreSQLParserESCAPE, PostgreSQLParserEVENT, PostgreSQLParserEXCLUDE, PostgreSQLParserEXCLUDING, PostgreSQLParserEXCLUSIVE, PostgreSQLParserEXECUTE, PostgreSQLParserEXPLAIN, PostgreSQLParserEXTENSION, PostgreSQLParserEXTERNAL, PostgreSQLParserFAMILY, PostgreSQLParserFIRST_P, PostgreSQLParserFOLLOWING, PostgreSQLParserFORCE, PostgreSQLParserFORWARD, PostgreSQLParserFUNCTION, PostgreSQLParserFUNCTIONS, PostgreSQLParserGLOBAL, PostgreSQLParserGRANTED, PostgreSQLParserHANDLER, PostgreSQLParserHEADER_P, PostgreSQLParserHOLD, PostgreSQLParserHOUR_P, PostgreSQLParserIDENTITY_P, PostgreSQLParserIF_P, PostgreSQLParserIMMEDIATE, PostgreSQLParserIMMUTABLE, PostgreSQLParserIMPLICIT_P, PostgreSQLParserINCLUDING, PostgreSQLParserINCREMENT, PostgreSQLParserINDEX, PostgreSQLParserINDEXES, PostgreSQLParserINHERIT, PostgreSQLParserINHERITS, PostgreSQLParserINLINE_P, PostgreSQLParserINSENSITIVE, PostgreSQLParserINSERT, PostgreSQLParserINSTEAD, PostgreSQLParserINVOKER, PostgreSQLParserISOLATION, PostgreSQLParserKEY, PostgreSQLParserLABEL, PostgreSQLParserLANGUAGE, PostgreSQLParserLARGE_P, PostgreSQLParserLAST_P, PostgreSQLParserLEAKPROOF, PostgreSQLParserLEVEL, PostgreSQLParserLISTEN, PostgreSQLParserLOAD, PostgreSQLParserLOCAL, PostgreSQLParserLOCATION, PostgreSQLParserLOCK_P, PostgreSQLParserMAPPING, PostgreSQLParserMATCH, PostgreSQLParserMATERIALIZED, PostgreSQLParserMAXVALUE, PostgreSQLParserMERGE, PostgreSQLParserMINUTE_P, PostgreSQLParserMINVALUE, PostgreSQLParserMODE, PostgreSQLParserMONTH_P, PostgreSQLParserMOVE, PostgreSQLParserNAME_P, PostgreSQLParserNAMES, PostgreSQLParserNEXT, PostgreSQLParserNO, PostgreSQLParserNOTHING, PostgreSQLParserNOTIFY, PostgreSQLParserNOWAIT, PostgreSQLParserNULLS_P, PostgreSQLParserOBJECT_P, PostgreSQLParserOF, PostgreSQLParserOFF, PostgreSQLParserOIDS, PostgreSQLParserOPERATOR, PostgreSQLParserOPTION, PostgreSQLParserOPTIONS, PostgreSQLParserOWNED, PostgreSQLParserOWNER, PostgreSQLParserPARSER, PostgreSQLParserPARTIAL, PostgreSQLParserPARTITION, PostgreSQLParserPASSING, PostgreSQLParserPASSWORD, PostgreSQLParserPLANS, PostgreSQLParserPRECEDING, PostgreSQLParserPREPARE, PostgreSQLParserPREPARED, PostgreSQLParserPRESERVE, PostgreSQLParserPRIOR, PostgreSQLParserPRIVILEGES, PostgreSQLParserPROCEDURAL, PostgreSQLParserPROCEDURE, PostgreSQLParserPROGRAM, PostgreSQLParserQUOTE, PostgreSQLParserRANGE, PostgreSQLParserREAD, PostgreSQLParserREASSIGN, PostgreSQLParserRECHECK, PostgreSQLParserRECURSIVE, PostgreSQLParserREF, PostgreSQLParserREFRESH, PostgreSQLParserREINDEX, PostgreSQLParserRELATIVE_P, PostgreSQLParserRELEASE, PostgreSQLParserRENAME, PostgreSQLParserREPEATABLE, PostgreSQLParserREPLACE, PostgreSQLParserREPLICA, PostgreSQLParserRESET, PostgreSQLParserRESTART, PostgreSQLParserRESTRICT, PostgreSQLParserRETURNS, PostgreSQLParserREVOKE, PostgreSQLParserROLE, PostgreSQLParserROLLBACK, PostgreSQLParserROWS, PostgreSQLParserRULE, PostgreSQLParserSAVEPOINT, PostgreSQLParserSCHEMA, PostgreSQLParserSCROLL, PostgreSQLParserSEARCH, PostgreSQLParserSECOND_P, PostgreSQLParserSECURITY, PostgreSQLParserSEQUENCE, PostgreSQLParserSEQUENCES, PostgreSQLParserSERIALIZABLE, PostgreSQLParserSERVER, PostgreSQLParserSESSION, PostgreSQLParserSET, PostgreSQLParserSHARE, PostgreSQLParserSHOW, PostgreSQLParserSIMPLE, PostgreSQLParserSNAPSHOT, PostgreSQLParserSTABLE, PostgreSQLParserSTANDALONE_P, PostgreSQLParserSTART, PostgreSQLParserSTATEMENT, PostgreSQLParserSTATISTICS, PostgreSQLParserSTDIN, PostgreSQLParserSTDOUT, PostgreSQLParserSTORAGE, PostgreSQLParserSTRICT_P, PostgreSQLParserSTRIP_P, PostgreSQLParserSYSID, PostgreSQLParserSYSTEM_P, PostgreSQLParserTABLES, PostgreSQLParserTABLESPACE, PostgreSQLParserTEMP, PostgreSQLParserTEMPLATE, PostgreSQLParserTEMPORARY, PostgreSQLParserTEXT_P, PostgreSQLParserTRANSACTION, PostgreSQLParserTRIGGER, PostgreSQLParserTRUNCATE, PostgreSQLParserTRUSTED, PostgreSQLParserTYPE_P, PostgreSQLParserTYPES_P, PostgreSQLParserUNBOUNDED, PostgreSQLParserUNCOMMITTED, PostgreSQLParserUNENCRYPTED, PostgreSQLParserUNKNOWN, PostgreSQLParserUNLISTEN, PostgreSQLParserUNLOGGED, PostgreSQLParserUNTIL, PostgreSQLParserUPDATE, PostgreSQLParserVACUUM, PostgreSQLParserVALID, PostgreSQLParserVALIDATE, PostgreSQLParserVALIDATOR, PostgreSQLParserVARYING, PostgreSQLParserVERSION_P, PostgreSQLParserVIEW, PostgreSQLParserVOLATILE, PostgreSQLParserWHITESPACE_P, PostgreSQLParserWITHOUT, PostgreSQLParserWORK, PostgreSQLParserWRAPPER, PostgreSQLParserWRITE, PostgreSQLParserXML_P, PostgreSQLParserYEAR_P, PostgreSQLParserYES_P, PostgreSQLParserZONE, PostgreSQLParserBETWEEN, PostgreSQLParserBIGINT, PostgreSQLParserBIT, PostgreSQLParserBOOLEAN_P, PostgreSQLParserCHAR_P, PostgreSQLParserCHARACTER, PostgreSQLParserCOALESCE, PostgreSQLParserDEC, PostgreSQLParserDECIMAL_P, PostgreSQLParserEXISTS, PostgreSQLParserEXTRACT, PostgreSQLParserFLOAT_P, PostgreSQLParserGREATEST, PostgreSQLParserINOUT, PostgreSQLParserINT_P, PostgreSQLParserINTEGER, PostgreSQLParserINTERVAL, PostgreSQLParserLEAST, PostgreSQLParserNATIONAL, PostgreSQLParserNCHAR, PostgreSQLParserNONE, PostgreSQLParserNULLIF, PostgreSQLParserNUMERIC, PostgreSQLParserOVERLAY, PostgreSQLParserPOSITION, PostgreSQLParserPRECISION, PostgreSQLParserREAL, PostgreSQLParserROW, PostgreSQLParserSETOF, PostgreSQLParserSMALLINT, PostgreSQLParserSUBSTRING, PostgreSQLParserTIME, PostgreSQLParserTIMESTAMP, PostgreSQLParserTREAT, PostgreSQLParserTRIM, PostgreSQLParserVALUES, PostgreSQLParserVARCHAR, PostgreSQLParserXMLATTRIBUTES, PostgreSQLParserXMLCOMMENT, PostgreSQLParserXMLAGG, PostgreSQLParserXML_IS_WELL_FORMED, PostgreSQLParserXML_IS_WELL_FORMED_DOCUMENT, PostgreSQLParserXML_IS_WELL_FORMED_CONTENT, PostgreSQLParserXPATH, PostgreSQLParserXPATH_EXISTS, PostgreSQLParserXMLCONCAT, PostgreSQLParserXMLELEMENT, PostgreSQLParserXMLEXISTS, PostgreSQLParserXMLFOREST, PostgreSQLParserXMLPARSE, PostgreSQLParserXMLPI, PostgreSQLParserXMLROOT, PostgreSQLParserXMLSERIALIZE, PostgreSQLParserCALL, PostgreSQLParserCURRENT_P, PostgreSQLParserATTACH, PostgreSQLParserDETACH, PostgreSQLParserEXPRESSION, PostgreSQLParserGENERATED, PostgreSQLParserLOGGED, PostgreSQLParserSTORED, PostgreSQLParserINCLUDE, PostgreSQLParserROUTINE, PostgreSQLParserTRANSFORM, PostgreSQLParserIMPORT_P, PostgreSQLParserPOLICY, PostgreSQLParserMETHOD, PostgreSQLParserREFERENCING, PostgreSQLParserNEW, PostgreSQLParserOLD, PostgreSQLParserVALUE_P, PostgreSQLParserSUBSCRIPTION, PostgreSQLParserPUBLICATION, PostgreSQLParserOUT_P, PostgreSQLParserEND_P, PostgreSQLParserROUTINES, PostgreSQLParserSCHEMAS, PostgreSQLParserPROCEDURES, PostgreSQLParserINPUT_P, PostgreSQLParserSUPPORT, PostgreSQLParserPARALLEL, PostgreSQLParserSQL_P, PostgreSQLParserDEPENDS, PostgreSQLParserOVERRIDING, PostgreSQLParserCONFLICT, PostgreSQLParserSKIP_P, PostgreSQLParserLOCKED, PostgreSQLParserTIES, PostgreSQLParserROLLUP, PostgreSQLParserCUBE, PostgreSQLParserGROUPING, PostgreSQLParserSETS, PostgreSQLParserORDINALITY, PostgreSQLParserXMLTABLE, PostgreSQLParserCOLUMNS, PostgreSQLParserXMLNAMESPACES, PostgreSQLParserROWTYPE, PostgreSQLParserNORMALIZED, PostgreSQLParserWITHIN, PostgreSQLParserFILTER, PostgreSQLParserGROUPS, PostgreSQLParserOTHERS, PostgreSQLParserNFC, PostgreSQLParserNFD, PostgreSQLParserNFKC, PostgreSQLParserNFKD, PostgreSQLParserUESCAPE, PostgreSQLParserVIEWS, PostgreSQLParserNORMALIZE, PostgreSQLParserDUMP, PostgreSQLParserPRINT_STRICT_PARAMS, PostgreSQLParserVARIABLE_CONFLICT, PostgreSQLParserERROR, PostgreSQLParserUSE_VARIABLE, PostgreSQLParserUSE_COLUMN, PostgreSQLParserALIAS, PostgreSQLParserCONSTANT, PostgreSQLParserPERFORM, PostgreSQLParserGET, PostgreSQLParserDIAGNOSTICS, PostgreSQLParserSTACKED, PostgreSQLParserELSIF, PostgreSQLParserREVERSE, PostgreSQLParserSLICE, PostgreSQLParserEXIT, PostgreSQLParserRETURN, PostgreSQLParserQUERY, PostgreSQLParserRAISE, PostgreSQLParserSQLSTATE, PostgreSQLParserDEBUG, PostgreSQLParserLOG, PostgreSQLParserINFO, PostgreSQLParserNOTICE, PostgreSQLParserWARNING, PostgreSQLParserEXCEPTION, PostgreSQLParserASSERT, PostgreSQLParserOPEN, PostgreSQLParserABS, PostgreSQLParserCBRT, PostgreSQLParserCEIL, PostgreSQLParserCEILING, PostgreSQLParserDEGREES, PostgreSQLParserDIV, PostgreSQLParserEXP, PostgreSQLParserFACTORIAL, PostgreSQLParserFLOOR, PostgreSQLParserGCD, PostgreSQLParserLCM, PostgreSQLParserLN, PostgreSQLParserLOG10, PostgreSQLParserMIN_SCALE, PostgreSQLParserMOD, PostgreSQLParserPI, PostgreSQLParserPOWER, PostgreSQLParserRADIANS, PostgreSQLParserROUND, PostgreSQLParserSCALE, PostgreSQLParserSIGN, PostgreSQLParserSQRT, PostgreSQLParserTRIM_SCALE, PostgreSQLParserTRUNC, PostgreSQLParserWIDTH_BUCKET, PostgreSQLParserRANDOM, PostgreSQLParserSETSEED, PostgreSQLParserACOS, PostgreSQLParserACOSD, PostgreSQLParserASIN, PostgreSQLParserASIND, PostgreSQLParserATAN, PostgreSQLParserATAND, PostgreSQLParserATAN2, PostgreSQLParserATAN2D, PostgreSQLParserCOS, PostgreSQLParserCOSD, PostgreSQLParserCOT, PostgreSQLParserCOTD, PostgreSQLParserSIN, PostgreSQLParserSIND, PostgreSQLParserTAN, PostgreSQLParserTAND, PostgreSQLParserSINH, PostgreSQLParserCOSH, PostgreSQLParserTANH, PostgreSQLParserASINH, PostgreSQLParserACOSH, PostgreSQLParserATANH, PostgreSQLParserBIT_LENGTH, PostgreSQLParserCHAR_LENGTH, PostgreSQLParserCHARACTER_LENGTH, PostgreSQLParserLOWER, PostgreSQLParserOCTET_LENGTH, PostgreSQLParserUPPER, PostgreSQLParserASCII, PostgreSQLParserBTRIM, PostgreSQLParserCHR, PostgreSQLParserCONCAT, PostgreSQLParserCONCAT_WS, PostgreSQLParserFORMAT, PostgreSQLParserINITCAP, PostgreSQLParserLENGTH, PostgreSQLParserLPAD, PostgreSQLParserLTRIM, PostgreSQLParserMD5, PostgreSQLParserPARSE_IDENT, PostgreSQLParserPG_CLIENT_ENCODING, PostgreSQLParserQUOTE_IDENT, PostgreSQLParserQUOTE_LITERAL, PostgreSQLParserQUOTE_NULLABLE, PostgreSQLParserREGEXP_COUNT, PostgreSQLParserREGEXP_INSTR, PostgreSQLParserREGEXP_LIKE, PostgreSQLParserREGEXP_MATCH, PostgreSQLParserREGEXP_MATCHES, PostgreSQLParserREGEXP_REPLACE, PostgreSQLParserREGEXP_SPLIT_TO_ARRAY, PostgreSQLParserREGEXP_SPLIT_TO_TABLE, PostgreSQLParserREGEXP_SUBSTR, PostgreSQLParserREPEAT, PostgreSQLParserRPAD, PostgreSQLParserRTRIM, PostgreSQLParserSPLIT_PART, PostgreSQLParserSTARTS_WITH, PostgreSQLParserSTRING_TO_ARRAY, PostgreSQLParserSTRING_TO_TABLE, PostgreSQLParserSTRPOS, PostgreSQLParserSUBSTR, PostgreSQLParserTO_ASCII, PostgreSQLParserTO_HEX, PostgreSQLParserTRANSLATE, PostgreSQLParserUNISTR, PostgreSQLParserAGE, PostgreSQLParserCLOCK_TIMESTAMP, PostgreSQLParserDATE_BIN, PostgreSQLParserDATE_PART, PostgreSQLParserDATE_TRUNC, PostgreSQLParserISFINITE, PostgreSQLParserJUSTIFY_DAYS, PostgreSQLParserJUSTIFY_HOURS, PostgreSQLParserJUSTIFY_INTERVAL, PostgreSQLParserMAKE_DATE, PostgreSQLParserMAKE_INTERVAL, PostgreSQLParserMAKE_TIME, PostgreSQLParserMAKE_TIMESTAMP, PostgreSQLParserMAKE_TIMESTAMPTZ, PostgreSQLParserNOW, PostgreSQLParserSTATEMENT_TIMESTAMP, PostgreSQLParserTIMEOFDAY, PostgreSQLParserTRANSACTION_TIMESTAMP, PostgreSQLParserTO_TIMESTAMP, PostgreSQLParserTO_CHAR, PostgreSQLParserTO_DATE, PostgreSQLParserTO_NUMBER, PostgreSQLParserIdentifier, PostgreSQLParserQuotedIdentifier, PostgreSQLParserUnicodeQuotedIdentifier, PostgreSQLParserPLSQLVARIABLENAME, PostgreSQLParserPLSQLIDENTIFIER, PostgreSQLParserMetaCommand:
		p.EnterOuterAlt(localctx, 2)

	default:
		p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IOpt_freezeContext is an interface to support dynamic dispatch.
type IOpt_freezeContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	FREEZE() antlr.TerminalNode

	// IsOpt_freezeContext differentiates from other interfaces.
	IsOpt_freezeContext()
}

type Opt_freezeContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyOpt_freezeContext() *Opt_freezeContext {
	var p = new(Opt_freezeContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opt_freeze
	return p
}

func InitEmptyOpt_freezeContext(p *Opt_freezeContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opt_freeze
}

func (*Opt_freezeContext) IsOpt_freezeContext() {}

func NewOpt_freezeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_freezeContext {
	var p = new(Opt_freezeContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_opt_freeze

	return p
}

func (s *Opt_freezeContext) GetParser() antlr.Parser { return s.parser }

func (s *Opt_freezeContext) FREEZE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserFREEZE, 0)
}

func (s *Opt_freezeContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Opt_freezeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Opt_freezeContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterOpt_freeze(s)
	}
}

func (s *Opt_freezeContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitOpt_freeze(s)
	}
}

func (s *Opt_freezeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitOpt_freeze(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Opt_freeze() (localctx IOpt_freezeContext) {
	localctx = NewOpt_freezeContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 868, PostgreSQLParserRULE_opt_freeze)
	p.SetState(7520)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetTokenStream().LA(1) {
	case PostgreSQLParserFREEZE:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(7518)
			p.Match(PostgreSQLParserFREEZE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case PostgreSQLParserEOF, PostgreSQLParserOPEN_PAREN, PostgreSQLParserSEMI, PostgreSQLParserANALYSE, PostgreSQLParserANALYZE, PostgreSQLParserAND, PostgreSQLParserARRAY, PostgreSQLParserCOLLATE, PostgreSQLParserCOLUMN, PostgreSQLParserCONSTRAINT, PostgreSQLParserCREATE, PostgreSQLParserDEFAULT, PostgreSQLParserDO, PostgreSQLParserFETCH, PostgreSQLParserGRANT, PostgreSQLParserINTO, PostgreSQLParserSELECT, PostgreSQLParserTABLE, PostgreSQLParserWITH, PostgreSQLParserIS, PostgreSQLParserLEFT, PostgreSQLParserOUTER_P, PostgreSQLParserOVER, PostgreSQLParserRIGHT, PostgreSQLParserVERBOSE, PostgreSQLParserABORT_P, PostgreSQLParserABSOLUTE_P, PostgreSQLParserACCESS, PostgreSQLParserACTION, PostgreSQLParserADD_P, PostgreSQLParserADMIN, PostgreSQLParserAFTER, PostgreSQLParserAGGREGATE, PostgreSQLParserALSO, PostgreSQLParserALTER, PostgreSQLParserALWAYS, PostgreSQLParserASSERTION, PostgreSQLParserASSIGNMENT, PostgreSQLParserAT, PostgreSQLParserATTRIBUTE, PostgreSQLParserBACKWARD, PostgreSQLParserBEFORE, PostgreSQLParserBEGIN_P, PostgreSQLParserBY, PostgreSQLParserCACHE, PostgreSQLParserCALLED, PostgreSQLParserCASCADE, PostgreSQLParserCASCADED, PostgreSQLParserCATALOG, PostgreSQLParserCHAIN, PostgreSQLParserCHARACTERISTICS, PostgreSQLParserCHECKPOINT, PostgreSQLParserCLASS, PostgreSQLParserCLOSE, PostgreSQLParserCLUSTER, PostgreSQLParserCOMMENT, PostgreSQLParserCOMMENTS, PostgreSQLParserCOMMIT, PostgreSQLParserCOMMITTED, PostgreSQLParserCONFIGURATION, PostgreSQLParserCONNECTION, PostgreSQLParserCONSTRAINTS, PostgreSQLParserCONTENT_P, PostgreSQLParserCONTINUE_P, PostgreSQLParserCONVERSION_P, PostgreSQLParserCOPY, PostgreSQLParserCOST, PostgreSQLParserCSV, PostgreSQLParserCURSOR, PostgreSQLParserCYCLE, PostgreSQLParserDATA_P, PostgreSQLParserDATABASE, PostgreSQLParserDAY_P, PostgreSQLParserDEALLOCATE, PostgreSQLParserDECLARE, PostgreSQLParserDEFAULTS, PostgreSQLParserDEFERRED, PostgreSQLParserDEFINER, PostgreSQLParserDELETE_P, PostgreSQLParserDELIMITER, PostgreSQLParserDELIMITERS, PostgreSQLParserDICTIONARY, PostgreSQLParserDISABLE_P, PostgreSQLParserDISCARD, PostgreSQLParserDOCUMENT_P, PostgreSQLParserDOMAIN_P, PostgreSQLParserDOUBLE_P, PostgreSQLParserDROP, PostgreSQLParserEACH, PostgreSQLParserENABLE_P, PostgreSQLParserENCODING, PostgreSQLParserENCRYPTED, PostgreSQLParserENUM_P, PostgreSQLParserESCAPE, PostgreSQLParserEVENT, PostgreSQLParserEXCLUDE, PostgreSQLParserEXCLUDING, PostgreSQLParserEXCLUSIVE, PostgreSQLParserEXECUTE, PostgreSQLParserEXPLAIN, PostgreSQLParserEXTENSION, PostgreSQLParserEXTERNAL, PostgreSQLParserFAMILY, PostgreSQLParserFIRST_P, PostgreSQLParserFOLLOWING, PostgreSQLParserFORCE, PostgreSQLParserFORWARD, PostgreSQLParserFUNCTION, PostgreSQLParserFUNCTIONS, PostgreSQLParserGLOBAL, PostgreSQLParserGRANTED, PostgreSQLParserHANDLER, PostgreSQLParserHEADER_P, PostgreSQLParserHOLD, PostgreSQLParserHOUR_P, PostgreSQLParserIDENTITY_P, PostgreSQLParserIF_P, PostgreSQLParserIMMEDIATE, PostgreSQLParserIMMUTABLE, PostgreSQLParserIMPLICIT_P, PostgreSQLParserINCLUDING, PostgreSQLParserINCREMENT, PostgreSQLParserINDEX, PostgreSQLParserINDEXES, PostgreSQLParserINHERIT, PostgreSQLParserINHERITS, PostgreSQLParserINLINE_P, PostgreSQLParserINSENSITIVE, PostgreSQLParserINSERT, PostgreSQLParserINSTEAD, PostgreSQLParserINVOKER, PostgreSQLParserISOLATION, PostgreSQLParserKEY, PostgreSQLParserLABEL, PostgreSQLParserLANGUAGE, PostgreSQLParserLARGE_P, PostgreSQLParserLAST_P, PostgreSQLParserLEAKPROOF, PostgreSQLParserLEVEL, PostgreSQLParserLISTEN, PostgreSQLParserLOAD, PostgreSQLParserLOCAL, PostgreSQLParserLOCATION, PostgreSQLParserLOCK_P, PostgreSQLParserMAPPING, PostgreSQLParserMATCH, PostgreSQLParserMATERIALIZED, PostgreSQLParserMAXVALUE, PostgreSQLParserMERGE, PostgreSQLParserMINUTE_P, PostgreSQLParserMINVALUE, PostgreSQLParserMODE, PostgreSQLParserMONTH_P, PostgreSQLParserMOVE, PostgreSQLParserNAME_P, PostgreSQLParserNAMES, PostgreSQLParserNEXT, PostgreSQLParserNO, PostgreSQLParserNOTHING, PostgreSQLParserNOTIFY, PostgreSQLParserNOWAIT, PostgreSQLParserNULLS_P, PostgreSQLParserOBJECT_P, PostgreSQLParserOF, PostgreSQLParserOFF, PostgreSQLParserOIDS, PostgreSQLParserOPERATOR, PostgreSQLParserOPTION, PostgreSQLParserOPTIONS, PostgreSQLParserOWNED, PostgreSQLParserOWNER, PostgreSQLParserPARSER, PostgreSQLParserPARTIAL, PostgreSQLParserPARTITION, PostgreSQLParserPASSING, PostgreSQLParserPASSWORD, PostgreSQLParserPLANS, PostgreSQLParserPRECEDING, PostgreSQLParserPREPARE, PostgreSQLParserPREPARED, PostgreSQLParserPRESERVE, PostgreSQLParserPRIOR, PostgreSQLParserPRIVILEGES, PostgreSQLParserPROCEDURAL, PostgreSQLParserPROCEDURE, PostgreSQLParserPROGRAM, PostgreSQLParserQUOTE, PostgreSQLParserRANGE, PostgreSQLParserREAD, PostgreSQLParserREASSIGN, PostgreSQLParserRECHECK, PostgreSQLParserRECURSIVE, PostgreSQLParserREF, PostgreSQLParserREFRESH, PostgreSQLParserREINDEX, PostgreSQLParserRELATIVE_P, PostgreSQLParserRELEASE, PostgreSQLParserRENAME, PostgreSQLParserREPEATABLE, PostgreSQLParserREPLACE, PostgreSQLParserREPLICA, PostgreSQLParserRESET, PostgreSQLParserRESTART, PostgreSQLParserRESTRICT, PostgreSQLParserRETURNS, PostgreSQLParserREVOKE, PostgreSQLParserROLE, PostgreSQLParserROLLBACK, PostgreSQLParserROWS, PostgreSQLParserRULE, PostgreSQLParserSAVEPOINT, PostgreSQLParserSCHEMA, PostgreSQLParserSCROLL, PostgreSQLParserSEARCH, PostgreSQLParserSECOND_P, PostgreSQLParserSECURITY, PostgreSQLParserSEQUENCE, PostgreSQLParserSEQUENCES, PostgreSQLParserSERIALIZABLE, PostgreSQLParserSERVER, PostgreSQLParserSESSION, PostgreSQLParserSET, PostgreSQLParserSHARE, PostgreSQLParserSHOW, PostgreSQLParserSIMPLE, PostgreSQLParserSNAPSHOT, PostgreSQLParserSTABLE, PostgreSQLParserSTANDALONE_P, PostgreSQLParserSTART, PostgreSQLParserSTATEMENT, PostgreSQLParserSTATISTICS, PostgreSQLParserSTDIN, PostgreSQLParserSTDOUT, PostgreSQLParserSTORAGE, PostgreSQLParserSTRICT_P, PostgreSQLParserSTRIP_P, PostgreSQLParserSYSID, PostgreSQLParserSYSTEM_P, PostgreSQLParserTABLES, PostgreSQLParserTABLESPACE, PostgreSQLParserTEMP, PostgreSQLParserTEMPLATE, PostgreSQLParserTEMPORARY, PostgreSQLParserTEXT_P, PostgreSQLParserTRANSACTION, PostgreSQLParserTRIGGER, PostgreSQLParserTRUNCATE, PostgreSQLParserTRUSTED, PostgreSQLParserTYPE_P, PostgreSQLParserTYPES_P, PostgreSQLParserUNBOUNDED, PostgreSQLParserUNCOMMITTED, PostgreSQLParserUNENCRYPTED, PostgreSQLParserUNKNOWN, PostgreSQLParserUNLISTEN, PostgreSQLParserUNLOGGED, PostgreSQLParserUNTIL, PostgreSQLParserUPDATE, PostgreSQLParserVACUUM, PostgreSQLParserVALID, PostgreSQLParserVALIDATE, PostgreSQLParserVALIDATOR, PostgreSQLParserVARYING, PostgreSQLParserVERSION_P, PostgreSQLParserVIEW, PostgreSQLParserVOLATILE, PostgreSQLParserWHITESPACE_P, PostgreSQLParserWITHOUT, PostgreSQLParserWORK, PostgreSQLParserWRAPPER, PostgreSQLParserWRITE, PostgreSQLParserXML_P, PostgreSQLParserYEAR_P, PostgreSQLParserYES_P, PostgreSQLParserZONE, PostgreSQLParserBETWEEN, PostgreSQLParserBIGINT, PostgreSQLParserBIT, PostgreSQLParserBOOLEAN_P, PostgreSQLParserCHAR_P, PostgreSQLParserCHARACTER, PostgreSQLParserCOALESCE, PostgreSQLParserDEC, PostgreSQLParserDECIMAL_P, PostgreSQLParserEXISTS, PostgreSQLParserEXTRACT, PostgreSQLParserFLOAT_P, PostgreSQLParserGREATEST, PostgreSQLParserINOUT, PostgreSQLParserINT_P, PostgreSQLParserINTEGER, PostgreSQLParserINTERVAL, PostgreSQLParserLEAST, PostgreSQLParserNATIONAL, PostgreSQLParserNCHAR, PostgreSQLParserNONE, PostgreSQLParserNULLIF, PostgreSQLParserNUMERIC, PostgreSQLParserOVERLAY, PostgreSQLParserPOSITION, PostgreSQLParserPRECISION, PostgreSQLParserREAL, PostgreSQLParserROW, PostgreSQLParserSETOF, PostgreSQLParserSMALLINT, PostgreSQLParserSUBSTRING, PostgreSQLParserTIME, PostgreSQLParserTIMESTAMP, PostgreSQLParserTREAT, PostgreSQLParserTRIM, PostgreSQLParserVALUES, PostgreSQLParserVARCHAR, PostgreSQLParserXMLATTRIBUTES, PostgreSQLParserXMLCOMMENT, PostgreSQLParserXMLAGG, PostgreSQLParserXML_IS_WELL_FORMED, PostgreSQLParserXML_IS_WELL_FORMED_DOCUMENT, PostgreSQLParserXML_IS_WELL_FORMED_CONTENT, PostgreSQLParserXPATH, PostgreSQLParserXPATH_EXISTS, PostgreSQLParserXMLCONCAT, PostgreSQLParserXMLELEMENT, PostgreSQLParserXMLEXISTS, PostgreSQLParserXMLFOREST, PostgreSQLParserXMLPARSE, PostgreSQLParserXMLPI, PostgreSQLParserXMLROOT, PostgreSQLParserXMLSERIALIZE, PostgreSQLParserCALL, PostgreSQLParserCURRENT_P, PostgreSQLParserATTACH, PostgreSQLParserDETACH, PostgreSQLParserEXPRESSION, PostgreSQLParserGENERATED, PostgreSQLParserLOGGED, PostgreSQLParserSTORED, PostgreSQLParserINCLUDE, PostgreSQLParserROUTINE, PostgreSQLParserTRANSFORM, PostgreSQLParserIMPORT_P, PostgreSQLParserPOLICY, PostgreSQLParserMETHOD, PostgreSQLParserREFERENCING, PostgreSQLParserNEW, PostgreSQLParserOLD, PostgreSQLParserVALUE_P, PostgreSQLParserSUBSCRIPTION, PostgreSQLParserPUBLICATION, PostgreSQLParserOUT_P, PostgreSQLParserEND_P, PostgreSQLParserROUTINES, PostgreSQLParserSCHEMAS, PostgreSQLParserPROCEDURES, PostgreSQLParserINPUT_P, PostgreSQLParserSUPPORT, PostgreSQLParserPARALLEL, PostgreSQLParserSQL_P, PostgreSQLParserDEPENDS, PostgreSQLParserOVERRIDING, PostgreSQLParserCONFLICT, PostgreSQLParserSKIP_P, PostgreSQLParserLOCKED, PostgreSQLParserTIES, PostgreSQLParserROLLUP, PostgreSQLParserCUBE, PostgreSQLParserGROUPING, PostgreSQLParserSETS, PostgreSQLParserORDINALITY, PostgreSQLParserXMLTABLE, PostgreSQLParserCOLUMNS, PostgreSQLParserXMLNAMESPACES, PostgreSQLParserROWTYPE, PostgreSQLParserNORMALIZED, PostgreSQLParserWITHIN, PostgreSQLParserFILTER, PostgreSQLParserGROUPS, PostgreSQLParserOTHERS, PostgreSQLParserNFC, PostgreSQLParserNFD, PostgreSQLParserNFKC, PostgreSQLParserNFKD, PostgreSQLParserUESCAPE, PostgreSQLParserVIEWS, PostgreSQLParserNORMALIZE, PostgreSQLParserDUMP, PostgreSQLParserPRINT_STRICT_PARAMS, PostgreSQLParserVARIABLE_CONFLICT, PostgreSQLParserERROR, PostgreSQLParserUSE_VARIABLE, PostgreSQLParserUSE_COLUMN, PostgreSQLParserALIAS, PostgreSQLParserCONSTANT, PostgreSQLParserPERFORM, PostgreSQLParserGET, PostgreSQLParserDIAGNOSTICS, PostgreSQLParserSTACKED, PostgreSQLParserELSIF, PostgreSQLParserREVERSE, PostgreSQLParserSLICE, PostgreSQLParserEXIT, PostgreSQLParserRETURN, PostgreSQLParserQUERY, PostgreSQLParserRAISE, PostgreSQLParserSQLSTATE, PostgreSQLParserDEBUG, PostgreSQLParserLOG, PostgreSQLParserINFO, PostgreSQLParserNOTICE, PostgreSQLParserWARNING, PostgreSQLParserEXCEPTION, PostgreSQLParserASSERT, PostgreSQLParserOPEN, PostgreSQLParserABS, PostgreSQLParserCBRT, PostgreSQLParserCEIL, PostgreSQLParserCEILING, PostgreSQLParserDEGREES, PostgreSQLParserDIV, PostgreSQLParserEXP, PostgreSQLParserFACTORIAL, PostgreSQLParserFLOOR, PostgreSQLParserGCD, PostgreSQLParserLCM, PostgreSQLParserLN, PostgreSQLParserLOG10, PostgreSQLParserMIN_SCALE, PostgreSQLParserMOD, PostgreSQLParserPI, PostgreSQLParserPOWER, PostgreSQLParserRADIANS, PostgreSQLParserROUND, PostgreSQLParserSCALE, PostgreSQLParserSIGN, PostgreSQLParserSQRT, PostgreSQLParserTRIM_SCALE, PostgreSQLParserTRUNC, PostgreSQLParserWIDTH_BUCKET, PostgreSQLParserRANDOM, PostgreSQLParserSETSEED, PostgreSQLParserACOS, PostgreSQLParserACOSD, PostgreSQLParserASIN, PostgreSQLParserASIND, PostgreSQLParserATAN, PostgreSQLParserATAND, PostgreSQLParserATAN2, PostgreSQLParserATAN2D, PostgreSQLParserCOS, PostgreSQLParserCOSD, PostgreSQLParserCOT, PostgreSQLParserCOTD, PostgreSQLParserSIN, PostgreSQLParserSIND, PostgreSQLParserTAN, PostgreSQLParserTAND, PostgreSQLParserSINH, PostgreSQLParserCOSH, PostgreSQLParserTANH, PostgreSQLParserASINH, PostgreSQLParserACOSH, PostgreSQLParserATANH, PostgreSQLParserBIT_LENGTH, PostgreSQLParserCHAR_LENGTH, PostgreSQLParserCHARACTER_LENGTH, PostgreSQLParserLOWER, PostgreSQLParserOCTET_LENGTH, PostgreSQLParserUPPER, PostgreSQLParserASCII, PostgreSQLParserBTRIM, PostgreSQLParserCHR, PostgreSQLParserCONCAT, PostgreSQLParserCONCAT_WS, PostgreSQLParserFORMAT, PostgreSQLParserINITCAP, PostgreSQLParserLENGTH, PostgreSQLParserLPAD, PostgreSQLParserLTRIM, PostgreSQLParserMD5, PostgreSQLParserPARSE_IDENT, PostgreSQLParserPG_CLIENT_ENCODING, PostgreSQLParserQUOTE_IDENT, PostgreSQLParserQUOTE_LITERAL, PostgreSQLParserQUOTE_NULLABLE, PostgreSQLParserREGEXP_COUNT, PostgreSQLParserREGEXP_INSTR, PostgreSQLParserREGEXP_LIKE, PostgreSQLParserREGEXP_MATCH, PostgreSQLParserREGEXP_MATCHES, PostgreSQLParserREGEXP_REPLACE, PostgreSQLParserREGEXP_SPLIT_TO_ARRAY, PostgreSQLParserREGEXP_SPLIT_TO_TABLE, PostgreSQLParserREGEXP_SUBSTR, PostgreSQLParserREPEAT, PostgreSQLParserRPAD, PostgreSQLParserRTRIM, PostgreSQLParserSPLIT_PART, PostgreSQLParserSTARTS_WITH, PostgreSQLParserSTRING_TO_ARRAY, PostgreSQLParserSTRING_TO_TABLE, PostgreSQLParserSTRPOS, PostgreSQLParserSUBSTR, PostgreSQLParserTO_ASCII, PostgreSQLParserTO_HEX, PostgreSQLParserTRANSLATE, PostgreSQLParserUNISTR, PostgreSQLParserAGE, PostgreSQLParserCLOCK_TIMESTAMP, PostgreSQLParserDATE_BIN, PostgreSQLParserDATE_PART, PostgreSQLParserDATE_TRUNC, PostgreSQLParserISFINITE, PostgreSQLParserJUSTIFY_DAYS, PostgreSQLParserJUSTIFY_HOURS, PostgreSQLParserJUSTIFY_INTERVAL, PostgreSQLParserMAKE_DATE, PostgreSQLParserMAKE_INTERVAL, PostgreSQLParserMAKE_TIME, PostgreSQLParserMAKE_TIMESTAMP, PostgreSQLParserMAKE_TIMESTAMPTZ, PostgreSQLParserNOW, PostgreSQLParserSTATEMENT_TIMESTAMP, PostgreSQLParserTIMEOFDAY, PostgreSQLParserTRANSACTION_TIMESTAMP, PostgreSQLParserTO_TIMESTAMP, PostgreSQLParserTO_CHAR, PostgreSQLParserTO_DATE, PostgreSQLParserTO_NUMBER, PostgreSQLParserIdentifier, PostgreSQLParserQuotedIdentifier, PostgreSQLParserUnicodeQuotedIdentifier, PostgreSQLParserPLSQLVARIABLENAME, PostgreSQLParserPLSQLIDENTIFIER, PostgreSQLParserMetaCommand:
		p.EnterOuterAlt(localctx, 2)

	default:
		p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IOpt_name_listContext is an interface to support dynamic dispatch.
type IOpt_name_listContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	OPEN_PAREN() antlr.TerminalNode
	Name_list() IName_listContext
	CLOSE_PAREN() antlr.TerminalNode

	// IsOpt_name_listContext differentiates from other interfaces.
	IsOpt_name_listContext()
}

type Opt_name_listContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyOpt_name_listContext() *Opt_name_listContext {
	var p = new(Opt_name_listContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opt_name_list
	return p
}

func InitEmptyOpt_name_listContext(p *Opt_name_listContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opt_name_list
}

func (*Opt_name_listContext) IsOpt_name_listContext() {}

func NewOpt_name_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_name_listContext {
	var p = new(Opt_name_listContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_opt_name_list

	return p
}

func (s *Opt_name_listContext) GetParser() antlr.Parser { return s.parser }

func (s *Opt_name_listContext) OPEN_PAREN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserOPEN_PAREN, 0)
}

func (s *Opt_name_listContext) Name_list() IName_listContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IName_listContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IName_listContext)
}

func (s *Opt_name_listContext) CLOSE_PAREN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCLOSE_PAREN, 0)
}

func (s *Opt_name_listContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Opt_name_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Opt_name_listContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterOpt_name_list(s)
	}
}

func (s *Opt_name_listContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitOpt_name_list(s)
	}
}

func (s *Opt_name_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitOpt_name_list(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Opt_name_list() (localctx IOpt_name_listContext) {
	localctx = NewOpt_name_listContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 870, PostgreSQLParserRULE_opt_name_list)
	p.SetState(7527)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 369, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(7522)
			p.Match(PostgreSQLParserOPEN_PAREN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(7523)
			p.Name_list()
		}
		{
			p.SetState(7524)
			p.Match(PostgreSQLParserCLOSE_PAREN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)

	case antlr.ATNInvalidAltNumber:
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IVacuum_relationContext is an interface to support dynamic dispatch.
type IVacuum_relationContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Qualified_name() IQualified_nameContext
	Opt_name_list() IOpt_name_listContext

	// IsVacuum_relationContext differentiates from other interfaces.
	IsVacuum_relationContext()
}

type Vacuum_relationContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyVacuum_relationContext() *Vacuum_relationContext {
	var p = new(Vacuum_relationContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_vacuum_relation
	return p
}

func InitEmptyVacuum_relationContext(p *Vacuum_relationContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_vacuum_relation
}

func (*Vacuum_relationContext) IsVacuum_relationContext() {}

func NewVacuum_relationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Vacuum_relationContext {
	var p = new(Vacuum_relationContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_vacuum_relation

	return p
}

func (s *Vacuum_relationContext) GetParser() antlr.Parser { return s.parser }

func (s *Vacuum_relationContext) Qualified_name() IQualified_nameContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IQualified_nameContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IQualified_nameContext)
}

func (s *Vacuum_relationContext) Opt_name_list() IOpt_name_listContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOpt_name_listContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOpt_name_listContext)
}

func (s *Vacuum_relationContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Vacuum_relationContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Vacuum_relationContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterVacuum_relation(s)
	}
}

func (s *Vacuum_relationContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitVacuum_relation(s)
	}
}

func (s *Vacuum_relationContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitVacuum_relation(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Vacuum_relation() (localctx IVacuum_relationContext) {
	localctx = NewVacuum_relationContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 872, PostgreSQLParserRULE_vacuum_relation)
	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(7529)
		p.Qualified_name()
	}
	{
		p.SetState(7530)
		p.Opt_name_list()
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IVacuum_relation_listContext is an interface to support dynamic dispatch.
type IVacuum_relation_listContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	AllVacuum_relation() []IVacuum_relationContext
	Vacuum_relation(i int) IVacuum_relationContext
	AllCOMMA() []antlr.TerminalNode
	COMMA(i int) antlr.TerminalNode

	// IsVacuum_relation_listContext differentiates from other interfaces.
	IsVacuum_relation_listContext()
}

type Vacuum_relation_listContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyVacuum_relation_listContext() *Vacuum_relation_listContext {
	var p = new(Vacuum_relation_listContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_vacuum_relation_list
	return p
}

func InitEmptyVacuum_relation_listContext(p *Vacuum_relation_listContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_vacuum_relation_list
}

func (*Vacuum_relation_listContext) IsVacuum_relation_listContext() {}

func NewVacuum_relation_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Vacuum_relation_listContext {
	var p = new(Vacuum_relation_listContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_vacuum_relation_list

	return p
}

func (s *Vacuum_relation_listContext) GetParser() antlr.Parser { return s.parser }

func (s *Vacuum_relation_listContext) AllVacuum_relation() []IVacuum_relationContext {
	children := s.GetChildren()
	len := 0
	for _, ctx := range children {
		if _, ok := ctx.(IVacuum_relationContext); ok {
			len++
		}
	}

	tst := make([]IVacuum_relationContext, len)
	i := 0
	for _, ctx := range children {
		if t, ok := ctx.(IVacuum_relationContext); ok {
			tst[i] = t.(IVacuum_relationContext)
			i++
		}
	}

	return tst
}

func (s *Vacuum_relation_listContext) Vacuum_relation(i int) IVacuum_relationContext {
	var t antlr.RuleContext
	j := 0
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IVacuum_relationContext); ok {
			if j == i {
				t = ctx.(antlr.RuleContext)
				break
			}
			j++
		}
	}

	if t == nil {
		return nil
	}

	return t.(IVacuum_relationContext)
}

func (s *Vacuum_relation_listContext) AllCOMMA() []antlr.TerminalNode {
	return s.GetTokens(PostgreSQLParserCOMMA)
}

func (s *Vacuum_relation_listContext) COMMA(i int) antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCOMMA, i)
}

func (s *Vacuum_relation_listContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Vacuum_relation_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Vacuum_relation_listContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterVacuum_relation_list(s)
	}
}

func (s *Vacuum_relation_listContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitVacuum_relation_list(s)
	}
}

func (s *Vacuum_relation_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitVacuum_relation_list(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Vacuum_relation_list() (localctx IVacuum_relation_listContext) {
	localctx = NewVacuum_relation_listContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 874, PostgreSQLParserRULE_vacuum_relation_list)
	var _la int

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(7532)
		p.Vacuum_relation()
	}
	p.SetState(7537)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}
	_la = p.GetTokenStream().LA(1)

	for _la == PostgreSQLParserCOMMA {
		{
			p.SetState(7533)
			p.Match(PostgreSQLParserCOMMA)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(7534)
			p.Vacuum_relation()
		}

		p.SetState(7539)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}
		_la = p.GetTokenStream().LA(1)
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IOpt_vacuum_relation_listContext is an interface to support dynamic dispatch.
type IOpt_vacuum_relation_listContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Vacuum_relation_list() IVacuum_relation_listContext

	// IsOpt_vacuum_relation_listContext differentiates from other interfaces.
	IsOpt_vacuum_relation_listContext()
}

type Opt_vacuum_relation_listContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyOpt_vacuum_relation_listContext() *Opt_vacuum_relation_listContext {
	var p = new(Opt_vacuum_relation_listContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opt_vacuum_relation_list
	return p
}

func InitEmptyOpt_vacuum_relation_listContext(p *Opt_vacuum_relation_listContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opt_vacuum_relation_list
}

func (*Opt_vacuum_relation_listContext) IsOpt_vacuum_relation_listContext() {}

func NewOpt_vacuum_relation_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_vacuum_relation_listContext {
	var p = new(Opt_vacuum_relation_listContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_opt_vacuum_relation_list

	return p
}

func (s *Opt_vacuum_relation_listContext) GetParser() antlr.Parser { return s.parser }

func (s *Opt_vacuum_relation_listContext) Vacuum_relation_list() IVacuum_relation_listContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IVacuum_relation_listContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IVacuum_relation_listContext)
}

func (s *Opt_vacuum_relation_listContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Opt_vacuum_relation_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Opt_vacuum_relation_listContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterOpt_vacuum_relation_list(s)
	}
}

func (s *Opt_vacuum_relation_listContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitOpt_vacuum_relation_list(s)
	}
}

func (s *Opt_vacuum_relation_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitOpt_vacuum_relation_list(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Opt_vacuum_relation_list() (localctx IOpt_vacuum_relation_listContext) {
	localctx = NewOpt_vacuum_relation_listContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 876, PostgreSQLParserRULE_opt_vacuum_relation_list)
	p.SetState(7542)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 371, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(7540)
			p.Vacuum_relation_list()
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)

	case antlr.ATNInvalidAltNumber:
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IExplainstmtContext is an interface to support dynamic dispatch.
type IExplainstmtContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	EXPLAIN() antlr.TerminalNode
	Explainablestmt() IExplainablestmtContext
	Analyze_keyword() IAnalyze_keywordContext
	Opt_verbose() IOpt_verboseContext
	VERBOSE() antlr.TerminalNode
	OPEN_PAREN() antlr.TerminalNode
	Explain_option_list() IExplain_option_listContext
	CLOSE_PAREN() antlr.TerminalNode

	// IsExplainstmtContext differentiates from other interfaces.
	IsExplainstmtContext()
}

type ExplainstmtContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyExplainstmtContext() *ExplainstmtContext {
	var p = new(ExplainstmtContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_explainstmt
	return p
}

func InitEmptyExplainstmtContext(p *ExplainstmtContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_explainstmt
}

func (*ExplainstmtContext) IsExplainstmtContext() {}

func NewExplainstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ExplainstmtContext {
	var p = new(ExplainstmtContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_explainstmt

	return p
}

func (s *ExplainstmtContext) GetParser() antlr.Parser { return s.parser }

func (s *ExplainstmtContext) EXPLAIN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserEXPLAIN, 0)
}

func (s *ExplainstmtContext) Explainablestmt() IExplainablestmtContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IExplainablestmtContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IExplainablestmtContext)
}

func (s *ExplainstmtContext) Analyze_keyword() IAnalyze_keywordContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IAnalyze_keywordContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IAnalyze_keywordContext)
}

func (s *ExplainstmtContext) Opt_verbose() IOpt_verboseContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOpt_verboseContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOpt_verboseContext)
}

func (s *ExplainstmtContext) VERBOSE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserVERBOSE, 0)
}

func (s *ExplainstmtContext) OPEN_PAREN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserOPEN_PAREN, 0)
}

func (s *ExplainstmtContext) Explain_option_list() IExplain_option_listContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IExplain_option_listContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IExplain_option_listContext)
}

func (s *ExplainstmtContext) CLOSE_PAREN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCLOSE_PAREN, 0)
}

func (s *ExplainstmtContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *ExplainstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *ExplainstmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterExplainstmt(s)
	}
}

func (s *ExplainstmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitExplainstmt(s)
	}
}

func (s *ExplainstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitExplainstmt(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Explainstmt() (localctx IExplainstmtContext) {
	localctx = NewExplainstmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 878, PostgreSQLParserRULE_explainstmt)
	p.SetState(7560)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 372, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(7544)
			p.Match(PostgreSQLParserEXPLAIN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(7545)
			p.Explainablestmt()
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(7546)
			p.Match(PostgreSQLParserEXPLAIN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(7547)
			p.Analyze_keyword()
		}
		{
			p.SetState(7548)
			p.Opt_verbose()
		}
		{
			p.SetState(7549)
			p.Explainablestmt()
		}

	case 3:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(7551)
			p.Match(PostgreSQLParserEXPLAIN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(7552)
			p.Match(PostgreSQLParserVERBOSE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(7553)
			p.Explainablestmt()
		}

	case 4:
		p.EnterOuterAlt(localctx, 4)
		{
			p.SetState(7554)
			p.Match(PostgreSQLParserEXPLAIN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(7555)
			p.Match(PostgreSQLParserOPEN_PAREN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(7556)
			p.Explain_option_list()
		}
		{
			p.SetState(7557)
			p.Match(PostgreSQLParserCLOSE_PAREN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(7558)
			p.Explainablestmt()
		}

	case antlr.ATNInvalidAltNumber:
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IExplainablestmtContext is an interface to support dynamic dispatch.
type IExplainablestmtContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Selectstmt() ISelectstmtContext
	Insertstmt() IInsertstmtContext
	Updatestmt() IUpdatestmtContext
	Deletestmt() IDeletestmtContext
	Declarecursorstmt() IDeclarecursorstmtContext
	Createasstmt() ICreateasstmtContext
	Creatematviewstmt() ICreatematviewstmtContext
	Refreshmatviewstmt() IRefreshmatviewstmtContext
	Executestmt() IExecutestmtContext

	// IsExplainablestmtContext differentiates from other interfaces.
	IsExplainablestmtContext()
}

type ExplainablestmtContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyExplainablestmtContext() *ExplainablestmtContext {
	var p = new(ExplainablestmtContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_explainablestmt
	return p
}

func InitEmptyExplainablestmtContext(p *ExplainablestmtContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_explainablestmt
}

func (*ExplainablestmtContext) IsExplainablestmtContext() {}

func NewExplainablestmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ExplainablestmtContext {
	var p = new(ExplainablestmtContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_explainablestmt

	return p
}

func (s *ExplainablestmtContext) GetParser() antlr.Parser { return s.parser }

func (s *ExplainablestmtContext) Selectstmt() ISelectstmtContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ISelectstmtContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ISelectstmtContext)
}

func (s *ExplainablestmtContext) Insertstmt() IInsertstmtContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IInsertstmtContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IInsertstmtContext)
}

func (s *ExplainablestmtContext) Updatestmt() IUpdatestmtContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IUpdatestmtContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IUpdatestmtContext)
}

func (s *ExplainablestmtContext) Deletestmt() IDeletestmtContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IDeletestmtContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IDeletestmtContext)
}

func (s *ExplainablestmtContext) Declarecursorstmt() IDeclarecursorstmtContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IDeclarecursorstmtContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IDeclarecursorstmtContext)
}

func (s *ExplainablestmtContext) Createasstmt() ICreateasstmtContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ICreateasstmtContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ICreateasstmtContext)
}

func (s *ExplainablestmtContext) Creatematviewstmt() ICreatematviewstmtContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ICreatematviewstmtContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ICreatematviewstmtContext)
}

func (s *ExplainablestmtContext) Refreshmatviewstmt() IRefreshmatviewstmtContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IRefreshmatviewstmtContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IRefreshmatviewstmtContext)
}

func (s *ExplainablestmtContext) Executestmt() IExecutestmtContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IExecutestmtContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IExecutestmtContext)
}

func (s *ExplainablestmtContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *ExplainablestmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *ExplainablestmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterExplainablestmt(s)
	}
}

func (s *ExplainablestmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitExplainablestmt(s)
	}
}

func (s *ExplainablestmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitExplainablestmt(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Explainablestmt() (localctx IExplainablestmtContext) {
	localctx = NewExplainablestmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 880, PostgreSQLParserRULE_explainablestmt)
	p.SetState(7571)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 373, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(7562)
			p.Selectstmt()
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(7563)
			p.Insertstmt()
		}

	case 3:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(7564)
			p.Updatestmt()
		}

	case 4:
		p.EnterOuterAlt(localctx, 4)
		{
			p.SetState(7565)
			p.Deletestmt()
		}

	case 5:
		p.EnterOuterAlt(localctx, 5)
		{
			p.SetState(7566)
			p.Declarecursorstmt()
		}

	case 6:
		p.EnterOuterAlt(localctx, 6)
		{
			p.SetState(7567)
			p.Createasstmt()
		}

	case 7:
		p.EnterOuterAlt(localctx, 7)
		{
			p.SetState(7568)
			p.Creatematviewstmt()
		}

	case 8:
		p.EnterOuterAlt(localctx, 8)
		{
			p.SetState(7569)
			p.Refreshmatviewstmt()
		}

	case 9:
		p.EnterOuterAlt(localctx, 9)
		{
			p.SetState(7570)
			p.Executestmt()
		}

	case antlr.ATNInvalidAltNumber:
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IExplain_option_listContext is an interface to support dynamic dispatch.
type IExplain_option_listContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	AllExplain_option_elem() []IExplain_option_elemContext
	Explain_option_elem(i int) IExplain_option_elemContext
	AllCOMMA() []antlr.TerminalNode
	COMMA(i int) antlr.TerminalNode

	// IsExplain_option_listContext differentiates from other interfaces.
	IsExplain_option_listContext()
}

type Explain_option_listContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyExplain_option_listContext() *Explain_option_listContext {
	var p = new(Explain_option_listContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_explain_option_list
	return p
}

func InitEmptyExplain_option_listContext(p *Explain_option_listContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_explain_option_list
}

func (*Explain_option_listContext) IsExplain_option_listContext() {}

func NewExplain_option_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Explain_option_listContext {
	var p = new(Explain_option_listContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_explain_option_list

	return p
}

func (s *Explain_option_listContext) GetParser() antlr.Parser { return s.parser }

func (s *Explain_option_listContext) AllExplain_option_elem() []IExplain_option_elemContext {
	children := s.GetChildren()
	len := 0
	for _, ctx := range children {
		if _, ok := ctx.(IExplain_option_elemContext); ok {
			len++
		}
	}

	tst := make([]IExplain_option_elemContext, len)
	i := 0
	for _, ctx := range children {
		if t, ok := ctx.(IExplain_option_elemContext); ok {
			tst[i] = t.(IExplain_option_elemContext)
			i++
		}
	}

	return tst
}

func (s *Explain_option_listContext) Explain_option_elem(i int) IExplain_option_elemContext {
	var t antlr.RuleContext
	j := 0
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IExplain_option_elemContext); ok {
			if j == i {
				t = ctx.(antlr.RuleContext)
				break
			}
			j++
		}
	}

	if t == nil {
		return nil
	}

	return t.(IExplain_option_elemContext)
}

func (s *Explain_option_listContext) AllCOMMA() []antlr.TerminalNode {
	return s.GetTokens(PostgreSQLParserCOMMA)
}

func (s *Explain_option_listContext) COMMA(i int) antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCOMMA, i)
}

func (s *Explain_option_listContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Explain_option_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Explain_option_listContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterExplain_option_list(s)
	}
}

func (s *Explain_option_listContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitExplain_option_list(s)
	}
}

func (s *Explain_option_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitExplain_option_list(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Explain_option_list() (localctx IExplain_option_listContext) {
	localctx = NewExplain_option_listContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 882, PostgreSQLParserRULE_explain_option_list)
	var _la int

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(7573)
		p.Explain_option_elem()
	}
	p.SetState(7578)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}
	_la = p.GetTokenStream().LA(1)

	for _la == PostgreSQLParserCOMMA {
		{
			p.SetState(7574)
			p.Match(PostgreSQLParserCOMMA)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(7575)
			p.Explain_option_elem()
		}

		p.SetState(7580)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}
		_la = p.GetTokenStream().LA(1)
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IExplain_option_elemContext is an interface to support dynamic dispatch.
type IExplain_option_elemContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Explain_option_name() IExplain_option_nameContext
	Explain_option_arg() IExplain_option_argContext

	// IsExplain_option_elemContext differentiates from other interfaces.
	IsExplain_option_elemContext()
}

type Explain_option_elemContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyExplain_option_elemContext() *Explain_option_elemContext {
	var p = new(Explain_option_elemContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_explain_option_elem
	return p
}

func InitEmptyExplain_option_elemContext(p *Explain_option_elemContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_explain_option_elem
}

func (*Explain_option_elemContext) IsExplain_option_elemContext() {}

func NewExplain_option_elemContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Explain_option_elemContext {
	var p = new(Explain_option_elemContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_explain_option_elem

	return p
}

func (s *Explain_option_elemContext) GetParser() antlr.Parser { return s.parser }

func (s *Explain_option_elemContext) Explain_option_name() IExplain_option_nameContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IExplain_option_nameContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IExplain_option_nameContext)
}

func (s *Explain_option_elemContext) Explain_option_arg() IExplain_option_argContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IExplain_option_argContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IExplain_option_argContext)
}

func (s *Explain_option_elemContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Explain_option_elemContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Explain_option_elemContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterExplain_option_elem(s)
	}
}

func (s *Explain_option_elemContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitExplain_option_elem(s)
	}
}

func (s *Explain_option_elemContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitExplain_option_elem(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Explain_option_elem() (localctx IExplain_option_elemContext) {
	localctx = NewExplain_option_elemContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 884, PostgreSQLParserRULE_explain_option_elem)
	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(7581)
		p.Explain_option_name()
	}
	{
		p.SetState(7582)
		p.Explain_option_arg()
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IExplain_option_nameContext is an interface to support dynamic dispatch.
type IExplain_option_nameContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Nonreservedword() INonreservedwordContext
	Analyze_keyword() IAnalyze_keywordContext

	// IsExplain_option_nameContext differentiates from other interfaces.
	IsExplain_option_nameContext()
}

type Explain_option_nameContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyExplain_option_nameContext() *Explain_option_nameContext {
	var p = new(Explain_option_nameContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_explain_option_name
	return p
}

func InitEmptyExplain_option_nameContext(p *Explain_option_nameContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_explain_option_name
}

func (*Explain_option_nameContext) IsExplain_option_nameContext() {}

func NewExplain_option_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Explain_option_nameContext {
	var p = new(Explain_option_nameContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_explain_option_name

	return p
}

func (s *Explain_option_nameContext) GetParser() antlr.Parser { return s.parser }

func (s *Explain_option_nameContext) Nonreservedword() INonreservedwordContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(INonreservedwordContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(INonreservedwordContext)
}

func (s *Explain_option_nameContext) Analyze_keyword() IAnalyze_keywordContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IAnalyze_keywordContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IAnalyze_keywordContext)
}

func (s *Explain_option_nameContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Explain_option_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Explain_option_nameContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterExplain_option_name(s)
	}
}

func (s *Explain_option_nameContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitExplain_option_name(s)
	}
}

func (s *Explain_option_nameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitExplain_option_name(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Explain_option_name() (localctx IExplain_option_nameContext) {
	localctx = NewExplain_option_nameContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 886, PostgreSQLParserRULE_explain_option_name)
	p.SetState(7586)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetTokenStream().LA(1) {
	case PostgreSQLParserAND, PostgreSQLParserARRAY, PostgreSQLParserCOLLATE, PostgreSQLParserCOLUMN, PostgreSQLParserCONSTRAINT, PostgreSQLParserDEFAULT, PostgreSQLParserDO, PostgreSQLParserFETCH, PostgreSQLParserTABLE, PostgreSQLParserAUTHORIZATION, PostgreSQLParserBINARY, PostgreSQLParserCOLLATION, PostgreSQLParserCONCURRENTLY, PostgreSQLParserCROSS, PostgreSQLParserCURRENT_SCHEMA, PostgreSQLParserFREEZE, PostgreSQLParserFULL, PostgreSQLParserILIKE, PostgreSQLParserINNER_P, PostgreSQLParserIS, PostgreSQLParserISNULL, PostgreSQLParserJOIN, PostgreSQLParserLIKE, PostgreSQLParserNATURAL, PostgreSQLParserNOTNULL, PostgreSQLParserOUTER_P, PostgreSQLParserOVER, PostgreSQLParserOVERLAPS, PostgreSQLParserSIMILAR, PostgreSQLParserVERBOSE, PostgreSQLParserABORT_P, PostgreSQLParserABSOLUTE_P, PostgreSQLParserACCESS, PostgreSQLParserACTION, PostgreSQLParserADD_P, PostgreSQLParserADMIN, PostgreSQLParserAFTER, PostgreSQLParserAGGREGATE, PostgreSQLParserALSO, PostgreSQLParserALTER, PostgreSQLParserALWAYS, PostgreSQLParserASSERTION, PostgreSQLParserASSIGNMENT, PostgreSQLParserAT, PostgreSQLParserATTRIBUTE, PostgreSQLParserBACKWARD, PostgreSQLParserBEFORE, PostgreSQLParserBEGIN_P, PostgreSQLParserBY, PostgreSQLParserCACHE, PostgreSQLParserCALLED, PostgreSQLParserCASCADE, PostgreSQLParserCASCADED, PostgreSQLParserCATALOG, PostgreSQLParserCHAIN, PostgreSQLParserCHARACTERISTICS, PostgreSQLParserCHECKPOINT, PostgreSQLParserCLASS, PostgreSQLParserCLOSE, PostgreSQLParserCLUSTER, PostgreSQLParserCOMMENT, PostgreSQLParserCOMMENTS, PostgreSQLParserCOMMIT, PostgreSQLParserCOMMITTED, PostgreSQLParserCONFIGURATION, PostgreSQLParserCONNECTION, PostgreSQLParserCONSTRAINTS, PostgreSQLParserCONTENT_P, PostgreSQLParserCONTINUE_P, PostgreSQLParserCONVERSION_P, PostgreSQLParserCOPY, PostgreSQLParserCOST, PostgreSQLParserCSV, PostgreSQLParserCURSOR, PostgreSQLParserCYCLE, PostgreSQLParserDATA_P, PostgreSQLParserDATABASE, PostgreSQLParserDAY_P, PostgreSQLParserDEALLOCATE, PostgreSQLParserDECLARE, PostgreSQLParserDEFAULTS, PostgreSQLParserDEFERRED, PostgreSQLParserDEFINER, PostgreSQLParserDELETE_P, PostgreSQLParserDELIMITER, PostgreSQLParserDELIMITERS, PostgreSQLParserDICTIONARY, PostgreSQLParserDISABLE_P, PostgreSQLParserDISCARD, PostgreSQLParserDOCUMENT_P, PostgreSQLParserDOMAIN_P, PostgreSQLParserDOUBLE_P, PostgreSQLParserDROP, PostgreSQLParserEACH, PostgreSQLParserENABLE_P, PostgreSQLParserENCODING, PostgreSQLParserENCRYPTED, PostgreSQLParserENUM_P, PostgreSQLParserESCAPE, PostgreSQLParserEVENT, PostgreSQLParserEXCLUDE, PostgreSQLParserEXCLUDING, PostgreSQLParserEXCLUSIVE, PostgreSQLParserEXECUTE, PostgreSQLParserEXPLAIN, PostgreSQLParserEXTENSION, PostgreSQLParserEXTERNAL, PostgreSQLParserFAMILY, PostgreSQLParserFIRST_P, PostgreSQLParserFOLLOWING, PostgreSQLParserFORCE, PostgreSQLParserFORWARD, PostgreSQLParserFUNCTION, PostgreSQLParserFUNCTIONS, PostgreSQLParserGLOBAL, PostgreSQLParserGRANTED, PostgreSQLParserHANDLER, PostgreSQLParserHEADER_P, PostgreSQLParserHOLD, PostgreSQLParserHOUR_P, PostgreSQLParserIDENTITY_P, PostgreSQLParserIF_P, PostgreSQLParserIMMEDIATE, PostgreSQLParserIMMUTABLE, PostgreSQLParserIMPLICIT_P, PostgreSQLParserINCLUDING, PostgreSQLParserINCREMENT, PostgreSQLParserINDEX, PostgreSQLParserINDEXES, PostgreSQLParserINHERIT, PostgreSQLParserINHERITS, PostgreSQLParserINLINE_P, PostgreSQLParserINSENSITIVE, PostgreSQLParserINSERT, PostgreSQLParserINSTEAD, PostgreSQLParserINVOKER, PostgreSQLParserISOLATION, PostgreSQLParserKEY, PostgreSQLParserLABEL, PostgreSQLParserLANGUAGE, PostgreSQLParserLARGE_P, PostgreSQLParserLAST_P, PostgreSQLParserLEAKPROOF, PostgreSQLParserLEVEL, PostgreSQLParserLISTEN, PostgreSQLParserLOAD, PostgreSQLParserLOCAL, PostgreSQLParserLOCATION, PostgreSQLParserLOCK_P, PostgreSQLParserMAPPING, PostgreSQLParserMATCH, PostgreSQLParserMATERIALIZED, PostgreSQLParserMAXVALUE, PostgreSQLParserMINUTE_P, PostgreSQLParserMINVALUE, PostgreSQLParserMODE, PostgreSQLParserMONTH_P, PostgreSQLParserMOVE, PostgreSQLParserNAME_P, PostgreSQLParserNAMES, PostgreSQLParserNEXT, PostgreSQLParserNO, PostgreSQLParserNOTHING, PostgreSQLParserNOTIFY, PostgreSQLParserNOWAIT, PostgreSQLParserNULLS_P, PostgreSQLParserOBJECT_P, PostgreSQLParserOF, PostgreSQLParserOFF, PostgreSQLParserOIDS, PostgreSQLParserOPERATOR, PostgreSQLParserOPTION, PostgreSQLParserOPTIONS, PostgreSQLParserOWNED, PostgreSQLParserOWNER, PostgreSQLParserPARSER, PostgreSQLParserPARTIAL, PostgreSQLParserPARTITION, PostgreSQLParserPASSING, PostgreSQLParserPASSWORD, PostgreSQLParserPLANS, PostgreSQLParserPRECEDING, PostgreSQLParserPREPARE, PostgreSQLParserPREPARED, PostgreSQLParserPRESERVE, PostgreSQLParserPRIOR, PostgreSQLParserPRIVILEGES, PostgreSQLParserPROCEDURAL, PostgreSQLParserPROCEDURE, PostgreSQLParserPROGRAM, PostgreSQLParserQUOTE, PostgreSQLParserRANGE, PostgreSQLParserREAD, PostgreSQLParserREASSIGN, PostgreSQLParserRECHECK, PostgreSQLParserRECURSIVE, PostgreSQLParserREF, PostgreSQLParserREFRESH, PostgreSQLParserREINDEX, PostgreSQLParserRELATIVE_P, PostgreSQLParserRELEASE, PostgreSQLParserRENAME, PostgreSQLParserREPEATABLE, PostgreSQLParserREPLACE, PostgreSQLParserREPLICA, PostgreSQLParserRESET, PostgreSQLParserRESTART, PostgreSQLParserRESTRICT, PostgreSQLParserRETURNS, PostgreSQLParserREVOKE, PostgreSQLParserROLE, PostgreSQLParserROLLBACK, PostgreSQLParserROWS, PostgreSQLParserRULE, PostgreSQLParserSAVEPOINT, PostgreSQLParserSCHEMA, PostgreSQLParserSCROLL, PostgreSQLParserSEARCH, PostgreSQLParserSECOND_P, PostgreSQLParserSECURITY, PostgreSQLParserSEQUENCE, PostgreSQLParserSEQUENCES, PostgreSQLParserSERIALIZABLE, PostgreSQLParserSERVER, PostgreSQLParserSESSION, PostgreSQLParserSET, PostgreSQLParserSHARE, PostgreSQLParserSHOW, PostgreSQLParserSIMPLE, PostgreSQLParserSNAPSHOT, PostgreSQLParserSTABLE, PostgreSQLParserSTANDALONE_P, PostgreSQLParserSTART, PostgreSQLParserSTATEMENT, PostgreSQLParserSTATISTICS, PostgreSQLParserSTDIN, PostgreSQLParserSTDOUT, PostgreSQLParserSTORAGE, PostgreSQLParserSTRICT_P, PostgreSQLParserSTRIP_P, PostgreSQLParserSYSID, PostgreSQLParserSYSTEM_P, PostgreSQLParserTABLES, PostgreSQLParserTABLESPACE, PostgreSQLParserTEMP, PostgreSQLParserTEMPLATE, PostgreSQLParserTEMPORARY, PostgreSQLParserTEXT_P, PostgreSQLParserTRANSACTION, PostgreSQLParserTRIGGER, PostgreSQLParserTRUNCATE, PostgreSQLParserTRUSTED, PostgreSQLParserTYPE_P, PostgreSQLParserTYPES_P, PostgreSQLParserUNBOUNDED, PostgreSQLParserUNCOMMITTED, PostgreSQLParserUNENCRYPTED, PostgreSQLParserUNKNOWN, PostgreSQLParserUNLISTEN, PostgreSQLParserUNLOGGED, PostgreSQLParserUNTIL, PostgreSQLParserUPDATE, PostgreSQLParserVACUUM, PostgreSQLParserVALID, PostgreSQLParserVALIDATE, PostgreSQLParserVALIDATOR, PostgreSQLParserVARYING, PostgreSQLParserVERSION_P, PostgreSQLParserVIEW, PostgreSQLParserVOLATILE, PostgreSQLParserWHITESPACE_P, PostgreSQLParserWITHOUT, PostgreSQLParserWORK, PostgreSQLParserWRAPPER, PostgreSQLParserWRITE, PostgreSQLParserXML_P, PostgreSQLParserYEAR_P, PostgreSQLParserYES_P, PostgreSQLParserZONE, PostgreSQLParserBETWEEN, PostgreSQLParserBIGINT, PostgreSQLParserBIT, PostgreSQLParserBOOLEAN_P, PostgreSQLParserCHAR_P, PostgreSQLParserCHARACTER, PostgreSQLParserCOALESCE, PostgreSQLParserDEC, PostgreSQLParserDECIMAL_P, PostgreSQLParserEXISTS, PostgreSQLParserEXTRACT, PostgreSQLParserFLOAT_P, PostgreSQLParserGREATEST, PostgreSQLParserINOUT, PostgreSQLParserINT_P, PostgreSQLParserINTEGER, PostgreSQLParserINTERVAL, PostgreSQLParserLEAST, PostgreSQLParserNATIONAL, PostgreSQLParserNCHAR, PostgreSQLParserNONE, PostgreSQLParserNULLIF, PostgreSQLParserNUMERIC, PostgreSQLParserOVERLAY, PostgreSQLParserPOSITION, PostgreSQLParserPRECISION, PostgreSQLParserREAL, PostgreSQLParserROW, PostgreSQLParserSETOF, PostgreSQLParserSMALLINT, PostgreSQLParserSUBSTRING, PostgreSQLParserTIME, PostgreSQLParserTIMESTAMP, PostgreSQLParserTREAT, PostgreSQLParserTRIM, PostgreSQLParserVALUES, PostgreSQLParserVARCHAR, PostgreSQLParserXMLATTRIBUTES, PostgreSQLParserXMLCOMMENT, PostgreSQLParserXMLAGG, PostgreSQLParserXML_IS_WELL_FORMED, PostgreSQLParserXML_IS_WELL_FORMED_DOCUMENT, PostgreSQLParserXML_IS_WELL_FORMED_CONTENT, PostgreSQLParserXPATH, PostgreSQLParserXPATH_EXISTS, PostgreSQLParserXMLCONCAT, PostgreSQLParserXMLELEMENT, PostgreSQLParserXMLEXISTS, PostgreSQLParserXMLFOREST, PostgreSQLParserXMLPARSE, PostgreSQLParserXMLPI, PostgreSQLParserXMLROOT, PostgreSQLParserXMLSERIALIZE, PostgreSQLParserCALL, PostgreSQLParserCURRENT_P, PostgreSQLParserATTACH, PostgreSQLParserDETACH, PostgreSQLParserEXPRESSION, PostgreSQLParserGENERATED, PostgreSQLParserLOGGED, PostgreSQLParserSTORED, PostgreSQLParserINCLUDE, PostgreSQLParserROUTINE, PostgreSQLParserTRANSFORM, PostgreSQLParserIMPORT_P, PostgreSQLParserPOLICY, PostgreSQLParserMETHOD, PostgreSQLParserREFERENCING, PostgreSQLParserNEW, PostgreSQLParserOLD, PostgreSQLParserVALUE_P, PostgreSQLParserSUBSCRIPTION, PostgreSQLParserPUBLICATION, PostgreSQLParserOUT_P, PostgreSQLParserROUTINES, PostgreSQLParserSCHEMAS, PostgreSQLParserPROCEDURES, PostgreSQLParserINPUT_P, PostgreSQLParserSUPPORT, PostgreSQLParserPARALLEL, PostgreSQLParserSQL_P, PostgreSQLParserDEPENDS, PostgreSQLParserOVERRIDING, PostgreSQLParserCONFLICT, PostgreSQLParserSKIP_P, PostgreSQLParserLOCKED, PostgreSQLParserTIES, PostgreSQLParserROLLUP, PostgreSQLParserCUBE, PostgreSQLParserGROUPING, PostgreSQLParserSETS, PostgreSQLParserTABLESAMPLE, PostgreSQLParserORDINALITY, PostgreSQLParserXMLTABLE, PostgreSQLParserCOLUMNS, PostgreSQLParserXMLNAMESPACES, PostgreSQLParserROWTYPE, PostgreSQLParserNORMALIZED, PostgreSQLParserWITHIN, PostgreSQLParserFILTER, PostgreSQLParserGROUPS, PostgreSQLParserOTHERS, PostgreSQLParserNFC, PostgreSQLParserNFD, PostgreSQLParserNFKC, PostgreSQLParserNFKD, PostgreSQLParserUESCAPE, PostgreSQLParserVIEWS, PostgreSQLParserNORMALIZE, PostgreSQLParserDUMP, PostgreSQLParserPRINT_STRICT_PARAMS, PostgreSQLParserVARIABLE_CONFLICT, PostgreSQLParserERROR, PostgreSQLParserUSE_VARIABLE, PostgreSQLParserUSE_COLUMN, PostgreSQLParserALIAS, PostgreSQLParserCONSTANT, PostgreSQLParserPERFORM, PostgreSQLParserGET, PostgreSQLParserDIAGNOSTICS, PostgreSQLParserSTACKED, PostgreSQLParserELSIF, PostgreSQLParserREVERSE, PostgreSQLParserSLICE, PostgreSQLParserEXIT, PostgreSQLParserRETURN, PostgreSQLParserQUERY, PostgreSQLParserRAISE, PostgreSQLParserSQLSTATE, PostgreSQLParserDEBUG, PostgreSQLParserLOG, PostgreSQLParserINFO, PostgreSQLParserNOTICE, PostgreSQLParserWARNING, PostgreSQLParserEXCEPTION, PostgreSQLParserASSERT, PostgreSQLParserOPEN, PostgreSQLParserABS, PostgreSQLParserCBRT, PostgreSQLParserCEIL, PostgreSQLParserCEILING, PostgreSQLParserDEGREES, PostgreSQLParserDIV, PostgreSQLParserEXP, PostgreSQLParserFACTORIAL, PostgreSQLParserFLOOR, PostgreSQLParserGCD, PostgreSQLParserLCM, PostgreSQLParserLN, PostgreSQLParserLOG10, PostgreSQLParserMIN_SCALE, PostgreSQLParserMOD, PostgreSQLParserPI, PostgreSQLParserPOWER, PostgreSQLParserRADIANS, PostgreSQLParserROUND, PostgreSQLParserSCALE, PostgreSQLParserSIGN, PostgreSQLParserSQRT, PostgreSQLParserTRIM_SCALE, PostgreSQLParserTRUNC, PostgreSQLParserWIDTH_BUCKET, PostgreSQLParserRANDOM, PostgreSQLParserSETSEED, PostgreSQLParserACOS, PostgreSQLParserACOSD, PostgreSQLParserASIN, PostgreSQLParserASIND, PostgreSQLParserATAN, PostgreSQLParserATAND, PostgreSQLParserATAN2, PostgreSQLParserATAN2D, PostgreSQLParserCOS, PostgreSQLParserCOSD, PostgreSQLParserCOT, PostgreSQLParserCOTD, PostgreSQLParserSIN, PostgreSQLParserSIND, PostgreSQLParserTAN, PostgreSQLParserTAND, PostgreSQLParserSINH, PostgreSQLParserCOSH, PostgreSQLParserTANH, PostgreSQLParserASINH, PostgreSQLParserACOSH, PostgreSQLParserATANH, PostgreSQLParserBIT_LENGTH, PostgreSQLParserCHAR_LENGTH, PostgreSQLParserCHARACTER_LENGTH, PostgreSQLParserLOWER, PostgreSQLParserOCTET_LENGTH, PostgreSQLParserUPPER, PostgreSQLParserASCII, PostgreSQLParserBTRIM, PostgreSQLParserCHR, PostgreSQLParserCONCAT, PostgreSQLParserCONCAT_WS, PostgreSQLParserFORMAT, PostgreSQLParserINITCAP, PostgreSQLParserLENGTH, PostgreSQLParserLPAD, PostgreSQLParserLTRIM, PostgreSQLParserMD5, PostgreSQLParserPARSE_IDENT, PostgreSQLParserPG_CLIENT_ENCODING, PostgreSQLParserQUOTE_IDENT, PostgreSQLParserQUOTE_LITERAL, PostgreSQLParserQUOTE_NULLABLE, PostgreSQLParserREGEXP_COUNT, PostgreSQLParserREGEXP_INSTR, PostgreSQLParserREGEXP_LIKE, PostgreSQLParserREGEXP_MATCH, PostgreSQLParserREGEXP_MATCHES, PostgreSQLParserREGEXP_REPLACE, PostgreSQLParserREGEXP_SPLIT_TO_ARRAY, PostgreSQLParserREGEXP_SPLIT_TO_TABLE, PostgreSQLParserREGEXP_SUBSTR, PostgreSQLParserREPEAT, PostgreSQLParserRPAD, PostgreSQLParserRTRIM, PostgreSQLParserSPLIT_PART, PostgreSQLParserSTARTS_WITH, PostgreSQLParserSTRING_TO_ARRAY, PostgreSQLParserSTRING_TO_TABLE, PostgreSQLParserSTRPOS, PostgreSQLParserSUBSTR, PostgreSQLParserTO_ASCII, PostgreSQLParserTO_HEX, PostgreSQLParserTRANSLATE, PostgreSQLParserUNISTR, PostgreSQLParserAGE, PostgreSQLParserCLOCK_TIMESTAMP, PostgreSQLParserDATE_BIN, PostgreSQLParserDATE_PART, PostgreSQLParserDATE_TRUNC, PostgreSQLParserISFINITE, PostgreSQLParserJUSTIFY_DAYS, PostgreSQLParserJUSTIFY_HOURS, PostgreSQLParserJUSTIFY_INTERVAL, PostgreSQLParserMAKE_DATE, PostgreSQLParserMAKE_INTERVAL, PostgreSQLParserMAKE_TIME, PostgreSQLParserMAKE_TIMESTAMP, PostgreSQLParserMAKE_TIMESTAMPTZ, PostgreSQLParserNOW, PostgreSQLParserSTATEMENT_TIMESTAMP, PostgreSQLParserTIMEOFDAY, PostgreSQLParserTRANSACTION_TIMESTAMP, PostgreSQLParserTO_TIMESTAMP, PostgreSQLParserTO_CHAR, PostgreSQLParserTO_DATE, PostgreSQLParserTO_NUMBER, PostgreSQLParserIdentifier, PostgreSQLParserQuotedIdentifier, PostgreSQLParserUnicodeQuotedIdentifier, PostgreSQLParserPLSQLVARIABLENAME, PostgreSQLParserPLSQLIDENTIFIER:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(7584)
			p.Nonreservedword()
		}

	case PostgreSQLParserANALYSE, PostgreSQLParserANALYZE:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(7585)
			p.Analyze_keyword()
		}

	default:
		p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IExplain_option_argContext is an interface to support dynamic dispatch.
type IExplain_option_argContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Opt_boolean_or_string() IOpt_boolean_or_stringContext
	Numericonly() INumericonlyContext

	// IsExplain_option_argContext differentiates from other interfaces.
	IsExplain_option_argContext()
}

type Explain_option_argContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyExplain_option_argContext() *Explain_option_argContext {
	var p = new(Explain_option_argContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_explain_option_arg
	return p
}

func InitEmptyExplain_option_argContext(p *Explain_option_argContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_explain_option_arg
}

func (*Explain_option_argContext) IsExplain_option_argContext() {}

func NewExplain_option_argContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Explain_option_argContext {
	var p = new(Explain_option_argContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_explain_option_arg

	return p
}

func (s *Explain_option_argContext) GetParser() antlr.Parser { return s.parser }

func (s *Explain_option_argContext) Opt_boolean_or_string() IOpt_boolean_or_stringContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOpt_boolean_or_stringContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOpt_boolean_or_stringContext)
}

func (s *Explain_option_argContext) Numericonly() INumericonlyContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(INumericonlyContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(INumericonlyContext)
}

func (s *Explain_option_argContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Explain_option_argContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Explain_option_argContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterExplain_option_arg(s)
	}
}

func (s *Explain_option_argContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitExplain_option_arg(s)
	}
}

func (s *Explain_option_argContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitExplain_option_arg(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Explain_option_arg() (localctx IExplain_option_argContext) {
	localctx = NewExplain_option_argContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 888, PostgreSQLParserRULE_explain_option_arg)
	p.SetState(7591)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetTokenStream().LA(1) {
	case PostgreSQLParserAND, PostgreSQLParserARRAY, PostgreSQLParserCOLLATE, PostgreSQLParserCOLUMN, PostgreSQLParserCONSTRAINT, PostgreSQLParserDEFAULT, PostgreSQLParserDO, PostgreSQLParserFALSE_P, PostgreSQLParserFETCH, PostgreSQLParserON, PostgreSQLParserTABLE, PostgreSQLParserTRUE_P, PostgreSQLParserAUTHORIZATION, PostgreSQLParserBINARY, PostgreSQLParserCOLLATION, PostgreSQLParserCONCURRENTLY, PostgreSQLParserCROSS, PostgreSQLParserCURRENT_SCHEMA, PostgreSQLParserFREEZE, PostgreSQLParserFULL, PostgreSQLParserILIKE, PostgreSQLParserINNER_P, PostgreSQLParserIS, PostgreSQLParserISNULL, PostgreSQLParserJOIN, PostgreSQLParserLIKE, PostgreSQLParserNATURAL, PostgreSQLParserNOTNULL, PostgreSQLParserOUTER_P, PostgreSQLParserOVER, PostgreSQLParserOVERLAPS, PostgreSQLParserSIMILAR, PostgreSQLParserVERBOSE, PostgreSQLParserABORT_P, PostgreSQLParserABSOLUTE_P, PostgreSQLParserACCESS, PostgreSQLParserACTION, PostgreSQLParserADD_P, PostgreSQLParserADMIN, PostgreSQLParserAFTER, PostgreSQLParserAGGREGATE, PostgreSQLParserALSO, PostgreSQLParserALTER, PostgreSQLParserALWAYS, PostgreSQLParserASSERTION, PostgreSQLParserASSIGNMENT, PostgreSQLParserAT, PostgreSQLParserATTRIBUTE, PostgreSQLParserBACKWARD, PostgreSQLParserBEFORE, PostgreSQLParserBEGIN_P, PostgreSQLParserBY, PostgreSQLParserCACHE, PostgreSQLParserCALLED, PostgreSQLParserCASCADE, PostgreSQLParserCASCADED, PostgreSQLParserCATALOG, PostgreSQLParserCHAIN, PostgreSQLParserCHARACTERISTICS, PostgreSQLParserCHECKPOINT, PostgreSQLParserCLASS, PostgreSQLParserCLOSE, PostgreSQLParserCLUSTER, PostgreSQLParserCOMMENT, PostgreSQLParserCOMMENTS, PostgreSQLParserCOMMIT, PostgreSQLParserCOMMITTED, PostgreSQLParserCONFIGURATION, PostgreSQLParserCONNECTION, PostgreSQLParserCONSTRAINTS, PostgreSQLParserCONTENT_P, PostgreSQLParserCONTINUE_P, PostgreSQLParserCONVERSION_P, PostgreSQLParserCOPY, PostgreSQLParserCOST, PostgreSQLParserCSV, PostgreSQLParserCURSOR, PostgreSQLParserCYCLE, PostgreSQLParserDATA_P, PostgreSQLParserDATABASE, PostgreSQLParserDAY_P, PostgreSQLParserDEALLOCATE, PostgreSQLParserDECLARE, PostgreSQLParserDEFAULTS, PostgreSQLParserDEFERRED, PostgreSQLParserDEFINER, PostgreSQLParserDELETE_P, PostgreSQLParserDELIMITER, PostgreSQLParserDELIMITERS, PostgreSQLParserDICTIONARY, PostgreSQLParserDISABLE_P, PostgreSQLParserDISCARD, PostgreSQLParserDOCUMENT_P, PostgreSQLParserDOMAIN_P, PostgreSQLParserDOUBLE_P, PostgreSQLParserDROP, PostgreSQLParserEACH, PostgreSQLParserENABLE_P, PostgreSQLParserENCODING, PostgreSQLParserENCRYPTED, PostgreSQLParserENUM_P, PostgreSQLParserESCAPE, PostgreSQLParserEVENT, PostgreSQLParserEXCLUDE, PostgreSQLParserEXCLUDING, PostgreSQLParserEXCLUSIVE, PostgreSQLParserEXECUTE, PostgreSQLParserEXPLAIN, PostgreSQLParserEXTENSION, PostgreSQLParserEXTERNAL, PostgreSQLParserFAMILY, PostgreSQLParserFIRST_P, PostgreSQLParserFOLLOWING, PostgreSQLParserFORCE, PostgreSQLParserFORWARD, PostgreSQLParserFUNCTION, PostgreSQLParserFUNCTIONS, PostgreSQLParserGLOBAL, PostgreSQLParserGRANTED, PostgreSQLParserHANDLER, PostgreSQLParserHEADER_P, PostgreSQLParserHOLD, PostgreSQLParserHOUR_P, PostgreSQLParserIDENTITY_P, PostgreSQLParserIF_P, PostgreSQLParserIMMEDIATE, PostgreSQLParserIMMUTABLE, PostgreSQLParserIMPLICIT_P, PostgreSQLParserINCLUDING, PostgreSQLParserINCREMENT, PostgreSQLParserINDEX, PostgreSQLParserINDEXES, PostgreSQLParserINHERIT, PostgreSQLParserINHERITS, PostgreSQLParserINLINE_P, PostgreSQLParserINSENSITIVE, PostgreSQLParserINSERT, PostgreSQLParserINSTEAD, PostgreSQLParserINVOKER, PostgreSQLParserISOLATION, PostgreSQLParserKEY, PostgreSQLParserLABEL, PostgreSQLParserLANGUAGE, PostgreSQLParserLARGE_P, PostgreSQLParserLAST_P, PostgreSQLParserLEAKPROOF, PostgreSQLParserLEVEL, PostgreSQLParserLISTEN, PostgreSQLParserLOAD, PostgreSQLParserLOCAL, PostgreSQLParserLOCATION, PostgreSQLParserLOCK_P, PostgreSQLParserMAPPING, PostgreSQLParserMATCH, PostgreSQLParserMATERIALIZED, PostgreSQLParserMAXVALUE, PostgreSQLParserMINUTE_P, PostgreSQLParserMINVALUE, PostgreSQLParserMODE, PostgreSQLParserMONTH_P, PostgreSQLParserMOVE, PostgreSQLParserNAME_P, PostgreSQLParserNAMES, PostgreSQLParserNEXT, PostgreSQLParserNO, PostgreSQLParserNOTHING, PostgreSQLParserNOTIFY, PostgreSQLParserNOWAIT, PostgreSQLParserNULLS_P, PostgreSQLParserOBJECT_P, PostgreSQLParserOF, PostgreSQLParserOFF, PostgreSQLParserOIDS, PostgreSQLParserOPERATOR, PostgreSQLParserOPTION, PostgreSQLParserOPTIONS, PostgreSQLParserOWNED, PostgreSQLParserOWNER, PostgreSQLParserPARSER, PostgreSQLParserPARTIAL, PostgreSQLParserPARTITION, PostgreSQLParserPASSING, PostgreSQLParserPASSWORD, PostgreSQLParserPLANS, PostgreSQLParserPRECEDING, PostgreSQLParserPREPARE, PostgreSQLParserPREPARED, PostgreSQLParserPRESERVE, PostgreSQLParserPRIOR, PostgreSQLParserPRIVILEGES, PostgreSQLParserPROCEDURAL, PostgreSQLParserPROCEDURE, PostgreSQLParserPROGRAM, PostgreSQLParserQUOTE, PostgreSQLParserRANGE, PostgreSQLParserREAD, PostgreSQLParserREASSIGN, PostgreSQLParserRECHECK, PostgreSQLParserRECURSIVE, PostgreSQLParserREF, PostgreSQLParserREFRESH, PostgreSQLParserREINDEX, PostgreSQLParserRELATIVE_P, PostgreSQLParserRELEASE, PostgreSQLParserRENAME, PostgreSQLParserREPEATABLE, PostgreSQLParserREPLACE, PostgreSQLParserREPLICA, PostgreSQLParserRESET, PostgreSQLParserRESTART, PostgreSQLParserRESTRICT, PostgreSQLParserRETURNS, PostgreSQLParserREVOKE, PostgreSQLParserROLE, PostgreSQLParserROLLBACK, PostgreSQLParserROWS, PostgreSQLParserRULE, PostgreSQLParserSAVEPOINT, PostgreSQLParserSCHEMA, PostgreSQLParserSCROLL, PostgreSQLParserSEARCH, PostgreSQLParserSECOND_P, PostgreSQLParserSECURITY, PostgreSQLParserSEQUENCE, PostgreSQLParserSEQUENCES, PostgreSQLParserSERIALIZABLE, PostgreSQLParserSERVER, PostgreSQLParserSESSION, PostgreSQLParserSET, PostgreSQLParserSHARE, PostgreSQLParserSHOW, PostgreSQLParserSIMPLE, PostgreSQLParserSNAPSHOT, PostgreSQLParserSTABLE, PostgreSQLParserSTANDALONE_P, PostgreSQLParserSTART, PostgreSQLParserSTATEMENT, PostgreSQLParserSTATISTICS, PostgreSQLParserSTDIN, PostgreSQLParserSTDOUT, PostgreSQLParserSTORAGE, PostgreSQLParserSTRICT_P, PostgreSQLParserSTRIP_P, PostgreSQLParserSYSID, PostgreSQLParserSYSTEM_P, PostgreSQLParserTABLES, PostgreSQLParserTABLESPACE, PostgreSQLParserTEMP, PostgreSQLParserTEMPLATE, PostgreSQLParserTEMPORARY, PostgreSQLParserTEXT_P, PostgreSQLParserTRANSACTION, PostgreSQLParserTRIGGER, PostgreSQLParserTRUNCATE, PostgreSQLParserTRUSTED, PostgreSQLParserTYPE_P, PostgreSQLParserTYPES_P, PostgreSQLParserUNBOUNDED, PostgreSQLParserUNCOMMITTED, PostgreSQLParserUNENCRYPTED, PostgreSQLParserUNKNOWN, PostgreSQLParserUNLISTEN, PostgreSQLParserUNLOGGED, PostgreSQLParserUNTIL, PostgreSQLParserUPDATE, PostgreSQLParserVACUUM, PostgreSQLParserVALID, PostgreSQLParserVALIDATE, PostgreSQLParserVALIDATOR, PostgreSQLParserVARYING, PostgreSQLParserVERSION_P, PostgreSQLParserVIEW, PostgreSQLParserVOLATILE, PostgreSQLParserWHITESPACE_P, PostgreSQLParserWITHOUT, PostgreSQLParserWORK, PostgreSQLParserWRAPPER, PostgreSQLParserWRITE, PostgreSQLParserXML_P, PostgreSQLParserYEAR_P, PostgreSQLParserYES_P, PostgreSQLParserZONE, PostgreSQLParserBETWEEN, PostgreSQLParserBIGINT, PostgreSQLParserBIT, PostgreSQLParserBOOLEAN_P, PostgreSQLParserCHAR_P, PostgreSQLParserCHARACTER, PostgreSQLParserCOALESCE, PostgreSQLParserDEC, PostgreSQLParserDECIMAL_P, PostgreSQLParserEXISTS, PostgreSQLParserEXTRACT, PostgreSQLParserFLOAT_P, PostgreSQLParserGREATEST, PostgreSQLParserINOUT, PostgreSQLParserINT_P, PostgreSQLParserINTEGER, PostgreSQLParserINTERVAL, PostgreSQLParserLEAST, PostgreSQLParserNATIONAL, PostgreSQLParserNCHAR, PostgreSQLParserNONE, PostgreSQLParserNULLIF, PostgreSQLParserNUMERIC, PostgreSQLParserOVERLAY, PostgreSQLParserPOSITION, PostgreSQLParserPRECISION, PostgreSQLParserREAL, PostgreSQLParserROW, PostgreSQLParserSETOF, PostgreSQLParserSMALLINT, PostgreSQLParserSUBSTRING, PostgreSQLParserTIME, PostgreSQLParserTIMESTAMP, PostgreSQLParserTREAT, PostgreSQLParserTRIM, PostgreSQLParserVALUES, PostgreSQLParserVARCHAR, PostgreSQLParserXMLATTRIBUTES, PostgreSQLParserXMLCOMMENT, PostgreSQLParserXMLAGG, PostgreSQLParserXML_IS_WELL_FORMED, PostgreSQLParserXML_IS_WELL_FORMED_DOCUMENT, PostgreSQLParserXML_IS_WELL_FORMED_CONTENT, PostgreSQLParserXPATH, PostgreSQLParserXPATH_EXISTS, PostgreSQLParserXMLCONCAT, PostgreSQLParserXMLELEMENT, PostgreSQLParserXMLEXISTS, PostgreSQLParserXMLFOREST, PostgreSQLParserXMLPARSE, PostgreSQLParserXMLPI, PostgreSQLParserXMLROOT, PostgreSQLParserXMLSERIALIZE, PostgreSQLParserCALL, PostgreSQLParserCURRENT_P, PostgreSQLParserATTACH, PostgreSQLParserDETACH, PostgreSQLParserEXPRESSION, PostgreSQLParserGENERATED, PostgreSQLParserLOGGED, PostgreSQLParserSTORED, PostgreSQLParserINCLUDE, PostgreSQLParserROUTINE, PostgreSQLParserTRANSFORM, PostgreSQLParserIMPORT_P, PostgreSQLParserPOLICY, PostgreSQLParserMETHOD, PostgreSQLParserREFERENCING, PostgreSQLParserNEW, PostgreSQLParserOLD, PostgreSQLParserVALUE_P, PostgreSQLParserSUBSCRIPTION, PostgreSQLParserPUBLICATION, PostgreSQLParserOUT_P, PostgreSQLParserROUTINES, PostgreSQLParserSCHEMAS, PostgreSQLParserPROCEDURES, PostgreSQLParserINPUT_P, PostgreSQLParserSUPPORT, PostgreSQLParserPARALLEL, PostgreSQLParserSQL_P, PostgreSQLParserDEPENDS, PostgreSQLParserOVERRIDING, PostgreSQLParserCONFLICT, PostgreSQLParserSKIP_P, PostgreSQLParserLOCKED, PostgreSQLParserTIES, PostgreSQLParserROLLUP, PostgreSQLParserCUBE, PostgreSQLParserGROUPING, PostgreSQLParserSETS, PostgreSQLParserTABLESAMPLE, PostgreSQLParserORDINALITY, PostgreSQLParserXMLTABLE, PostgreSQLParserCOLUMNS, PostgreSQLParserXMLNAMESPACES, PostgreSQLParserROWTYPE, PostgreSQLParserNORMALIZED, PostgreSQLParserWITHIN, PostgreSQLParserFILTER, PostgreSQLParserGROUPS, PostgreSQLParserOTHERS, PostgreSQLParserNFC, PostgreSQLParserNFD, PostgreSQLParserNFKC, PostgreSQLParserNFKD, PostgreSQLParserUESCAPE, PostgreSQLParserVIEWS, PostgreSQLParserNORMALIZE, PostgreSQLParserDUMP, PostgreSQLParserPRINT_STRICT_PARAMS, PostgreSQLParserVARIABLE_CONFLICT, PostgreSQLParserERROR, PostgreSQLParserUSE_VARIABLE, PostgreSQLParserUSE_COLUMN, PostgreSQLParserALIAS, PostgreSQLParserCONSTANT, PostgreSQLParserPERFORM, PostgreSQLParserGET, PostgreSQLParserDIAGNOSTICS, PostgreSQLParserSTACKED, PostgreSQLParserELSIF, PostgreSQLParserREVERSE, PostgreSQLParserSLICE, PostgreSQLParserEXIT, PostgreSQLParserRETURN, PostgreSQLParserQUERY, PostgreSQLParserRAISE, PostgreSQLParserSQLSTATE, PostgreSQLParserDEBUG, PostgreSQLParserLOG, PostgreSQLParserINFO, PostgreSQLParserNOTICE, PostgreSQLParserWARNING, PostgreSQLParserEXCEPTION, PostgreSQLParserASSERT, PostgreSQLParserOPEN, PostgreSQLParserABS, PostgreSQLParserCBRT, PostgreSQLParserCEIL, PostgreSQLParserCEILING, PostgreSQLParserDEGREES, PostgreSQLParserDIV, PostgreSQLParserEXP, PostgreSQLParserFACTORIAL, PostgreSQLParserFLOOR, PostgreSQLParserGCD, PostgreSQLParserLCM, PostgreSQLParserLN, PostgreSQLParserLOG10, PostgreSQLParserMIN_SCALE, PostgreSQLParserMOD, PostgreSQLParserPI, PostgreSQLParserPOWER, PostgreSQLParserRADIANS, PostgreSQLParserROUND, PostgreSQLParserSCALE, PostgreSQLParserSIGN, PostgreSQLParserSQRT, PostgreSQLParserTRIM_SCALE, PostgreSQLParserTRUNC, PostgreSQLParserWIDTH_BUCKET, PostgreSQLParserRANDOM, PostgreSQLParserSETSEED, PostgreSQLParserACOS, PostgreSQLParserACOSD, PostgreSQLParserASIN, PostgreSQLParserASIND, PostgreSQLParserATAN, PostgreSQLParserATAND, PostgreSQLParserATAN2, PostgreSQLParserATAN2D, PostgreSQLParserCOS, PostgreSQLParserCOSD, PostgreSQLParserCOT, PostgreSQLParserCOTD, PostgreSQLParserSIN, PostgreSQLParserSIND, PostgreSQLParserTAN, PostgreSQLParserTAND, PostgreSQLParserSINH, PostgreSQLParserCOSH, PostgreSQLParserTANH, PostgreSQLParserASINH, PostgreSQLParserACOSH, PostgreSQLParserATANH, PostgreSQLParserBIT_LENGTH, PostgreSQLParserCHAR_LENGTH, PostgreSQLParserCHARACTER_LENGTH, PostgreSQLParserLOWER, PostgreSQLParserOCTET_LENGTH, PostgreSQLParserUPPER, PostgreSQLParserASCII, PostgreSQLParserBTRIM, PostgreSQLParserCHR, PostgreSQLParserCONCAT, PostgreSQLParserCONCAT_WS, PostgreSQLParserFORMAT, PostgreSQLParserINITCAP, PostgreSQLParserLENGTH, PostgreSQLParserLPAD, PostgreSQLParserLTRIM, PostgreSQLParserMD5, PostgreSQLParserPARSE_IDENT, PostgreSQLParserPG_CLIENT_ENCODING, PostgreSQLParserQUOTE_IDENT, PostgreSQLParserQUOTE_LITERAL, PostgreSQLParserQUOTE_NULLABLE, PostgreSQLParserREGEXP_COUNT, PostgreSQLParserREGEXP_INSTR, PostgreSQLParserREGEXP_LIKE, PostgreSQLParserREGEXP_MATCH, PostgreSQLParserREGEXP_MATCHES, PostgreSQLParserREGEXP_REPLACE, PostgreSQLParserREGEXP_SPLIT_TO_ARRAY, PostgreSQLParserREGEXP_SPLIT_TO_TABLE, PostgreSQLParserREGEXP_SUBSTR, PostgreSQLParserREPEAT, PostgreSQLParserRPAD, PostgreSQLParserRTRIM, PostgreSQLParserSPLIT_PART, PostgreSQLParserSTARTS_WITH, PostgreSQLParserSTRING_TO_ARRAY, PostgreSQLParserSTRING_TO_TABLE, PostgreSQLParserSTRPOS, PostgreSQLParserSUBSTR, PostgreSQLParserTO_ASCII, PostgreSQLParserTO_HEX, PostgreSQLParserTRANSLATE, PostgreSQLParserUNISTR, PostgreSQLParserAGE, PostgreSQLParserCLOCK_TIMESTAMP, PostgreSQLParserDATE_BIN, PostgreSQLParserDATE_PART, PostgreSQLParserDATE_TRUNC, PostgreSQLParserISFINITE, PostgreSQLParserJUSTIFY_DAYS, PostgreSQLParserJUSTIFY_HOURS, PostgreSQLParserJUSTIFY_INTERVAL, PostgreSQLParserMAKE_DATE, PostgreSQLParserMAKE_INTERVAL, PostgreSQLParserMAKE_TIME, PostgreSQLParserMAKE_TIMESTAMP, PostgreSQLParserMAKE_TIMESTAMPTZ, PostgreSQLParserNOW, PostgreSQLParserSTATEMENT_TIMESTAMP, PostgreSQLParserTIMEOFDAY, PostgreSQLParserTRANSACTION_TIMESTAMP, PostgreSQLParserTO_TIMESTAMP, PostgreSQLParserTO_CHAR, PostgreSQLParserTO_DATE, PostgreSQLParserTO_NUMBER, PostgreSQLParserIdentifier, PostgreSQLParserQuotedIdentifier, PostgreSQLParserUnicodeQuotedIdentifier, PostgreSQLParserStringConstant, PostgreSQLParserUnicodeEscapeStringConstant, PostgreSQLParserBeginDollarStringConstant, PostgreSQLParserPLSQLVARIABLENAME, PostgreSQLParserPLSQLIDENTIFIER, PostgreSQLParserEscapeStringConstant:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(7588)
			p.Opt_boolean_or_string()
		}

	case PostgreSQLParserPLUS, PostgreSQLParserMINUS, PostgreSQLParserIntegral, PostgreSQLParserNumeric:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(7589)
			p.Numericonly()
		}

	case PostgreSQLParserCLOSE_PAREN, PostgreSQLParserCOMMA:
		p.EnterOuterAlt(localctx, 3)

	default:
		p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IPreparestmtContext is an interface to support dynamic dispatch.
type IPreparestmtContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	PREPARE() antlr.TerminalNode
	Name() INameContext
	Prep_type_clause() IPrep_type_clauseContext
	AS() antlr.TerminalNode
	Preparablestmt() IPreparablestmtContext

	// IsPreparestmtContext differentiates from other interfaces.
	IsPreparestmtContext()
}

type PreparestmtContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyPreparestmtContext() *PreparestmtContext {
	var p = new(PreparestmtContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_preparestmt
	return p
}

func InitEmptyPreparestmtContext(p *PreparestmtContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_preparestmt
}

func (*PreparestmtContext) IsPreparestmtContext() {}

func NewPreparestmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *PreparestmtContext {
	var p = new(PreparestmtContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_preparestmt

	return p
}

func (s *PreparestmtContext) GetParser() antlr.Parser { return s.parser }

func (s *PreparestmtContext) PREPARE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserPREPARE, 0)
}

func (s *PreparestmtContext) Name() INameContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(INameContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(INameContext)
}

func (s *PreparestmtContext) Prep_type_clause() IPrep_type_clauseContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IPrep_type_clauseContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IPrep_type_clauseContext)
}

func (s *PreparestmtContext) AS() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserAS, 0)
}

func (s *PreparestmtContext) Preparablestmt() IPreparablestmtContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IPreparablestmtContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IPreparablestmtContext)
}

func (s *PreparestmtContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *PreparestmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *PreparestmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterPreparestmt(s)
	}
}

func (s *PreparestmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitPreparestmt(s)
	}
}

func (s *PreparestmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitPreparestmt(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Preparestmt() (localctx IPreparestmtContext) {
	localctx = NewPreparestmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 890, PostgreSQLParserRULE_preparestmt)
	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(7593)
		p.Match(PostgreSQLParserPREPARE)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(7594)
		p.Name()
	}
	{
		p.SetState(7595)
		p.Prep_type_clause()
	}
	{
		p.SetState(7596)
		p.Match(PostgreSQLParserAS)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(7597)
		p.Preparablestmt()
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IPrep_type_clauseContext is an interface to support dynamic dispatch.
type IPrep_type_clauseContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	OPEN_PAREN() antlr.TerminalNode
	Type_list() IType_listContext
	CLOSE_PAREN() antlr.TerminalNode

	// IsPrep_type_clauseContext differentiates from other interfaces.
	IsPrep_type_clauseContext()
}

type Prep_type_clauseContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyPrep_type_clauseContext() *Prep_type_clauseContext {
	var p = new(Prep_type_clauseContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_prep_type_clause
	return p
}

func InitEmptyPrep_type_clauseContext(p *Prep_type_clauseContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_prep_type_clause
}

func (*Prep_type_clauseContext) IsPrep_type_clauseContext() {}

func NewPrep_type_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Prep_type_clauseContext {
	var p = new(Prep_type_clauseContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_prep_type_clause

	return p
}

func (s *Prep_type_clauseContext) GetParser() antlr.Parser { return s.parser }

func (s *Prep_type_clauseContext) OPEN_PAREN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserOPEN_PAREN, 0)
}

func (s *Prep_type_clauseContext) Type_list() IType_listContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IType_listContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IType_listContext)
}

func (s *Prep_type_clauseContext) CLOSE_PAREN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCLOSE_PAREN, 0)
}

func (s *Prep_type_clauseContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Prep_type_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Prep_type_clauseContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterPrep_type_clause(s)
	}
}

func (s *Prep_type_clauseContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitPrep_type_clause(s)
	}
}

func (s *Prep_type_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitPrep_type_clause(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Prep_type_clause() (localctx IPrep_type_clauseContext) {
	localctx = NewPrep_type_clauseContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 892, PostgreSQLParserRULE_prep_type_clause)
	p.SetState(7604)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetTokenStream().LA(1) {
	case PostgreSQLParserOPEN_PAREN:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(7599)
			p.Match(PostgreSQLParserOPEN_PAREN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(7600)
			p.Type_list()
		}
		{
			p.SetState(7601)
			p.Match(PostgreSQLParserCLOSE_PAREN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case PostgreSQLParserAS:
		p.EnterOuterAlt(localctx, 2)

	default:
		p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IPreparablestmtContext is an interface to support dynamic dispatch.
type IPreparablestmtContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Selectstmt() ISelectstmtContext
	Insertstmt() IInsertstmtContext
	Updatestmt() IUpdatestmtContext
	Deletestmt() IDeletestmtContext

	// IsPreparablestmtContext differentiates from other interfaces.
	IsPreparablestmtContext()
}

type PreparablestmtContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyPreparablestmtContext() *PreparablestmtContext {
	var p = new(PreparablestmtContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_preparablestmt
	return p
}

func InitEmptyPreparablestmtContext(p *PreparablestmtContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_preparablestmt
}

func (*PreparablestmtContext) IsPreparablestmtContext() {}

func NewPreparablestmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *PreparablestmtContext {
	var p = new(PreparablestmtContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_preparablestmt

	return p
}

func (s *PreparablestmtContext) GetParser() antlr.Parser { return s.parser }

func (s *PreparablestmtContext) Selectstmt() ISelectstmtContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ISelectstmtContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ISelectstmtContext)
}

func (s *PreparablestmtContext) Insertstmt() IInsertstmtContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IInsertstmtContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IInsertstmtContext)
}

func (s *PreparablestmtContext) Updatestmt() IUpdatestmtContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IUpdatestmtContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IUpdatestmtContext)
}

func (s *PreparablestmtContext) Deletestmt() IDeletestmtContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IDeletestmtContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IDeletestmtContext)
}

func (s *PreparablestmtContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *PreparablestmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *PreparablestmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterPreparablestmt(s)
	}
}

func (s *PreparablestmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitPreparablestmt(s)
	}
}

func (s *PreparablestmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitPreparablestmt(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Preparablestmt() (localctx IPreparablestmtContext) {
	localctx = NewPreparablestmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 894, PostgreSQLParserRULE_preparablestmt)
	p.SetState(7610)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 378, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(7606)
			p.Selectstmt()
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(7607)
			p.Insertstmt()
		}

	case 3:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(7608)
			p.Updatestmt()
		}

	case 4:
		p.EnterOuterAlt(localctx, 4)
		{
			p.SetState(7609)
			p.Deletestmt()
		}

	case antlr.ATNInvalidAltNumber:
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IExecutestmtContext is an interface to support dynamic dispatch.
type IExecutestmtContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	EXECUTE() antlr.TerminalNode
	Name() INameContext
	Execute_param_clause() IExecute_param_clauseContext
	CREATE() antlr.TerminalNode
	Opttemp() IOpttempContext
	TABLE() antlr.TerminalNode
	Create_as_target() ICreate_as_targetContext
	AS() antlr.TerminalNode
	Opt_with_data() IOpt_with_dataContext
	IF_P() antlr.TerminalNode
	NOT() antlr.TerminalNode
	EXISTS() antlr.TerminalNode

	// IsExecutestmtContext differentiates from other interfaces.
	IsExecutestmtContext()
}

type ExecutestmtContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyExecutestmtContext() *ExecutestmtContext {
	var p = new(ExecutestmtContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_executestmt
	return p
}

func InitEmptyExecutestmtContext(p *ExecutestmtContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_executestmt
}

func (*ExecutestmtContext) IsExecutestmtContext() {}

func NewExecutestmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ExecutestmtContext {
	var p = new(ExecutestmtContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_executestmt

	return p
}

func (s *ExecutestmtContext) GetParser() antlr.Parser { return s.parser }

func (s *ExecutestmtContext) EXECUTE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserEXECUTE, 0)
}

func (s *ExecutestmtContext) Name() INameContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(INameContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(INameContext)
}

func (s *ExecutestmtContext) Execute_param_clause() IExecute_param_clauseContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IExecute_param_clauseContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IExecute_param_clauseContext)
}

func (s *ExecutestmtContext) CREATE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCREATE, 0)
}

func (s *ExecutestmtContext) Opttemp() IOpttempContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOpttempContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOpttempContext)
}

func (s *ExecutestmtContext) TABLE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserTABLE, 0)
}

func (s *ExecutestmtContext) Create_as_target() ICreate_as_targetContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ICreate_as_targetContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ICreate_as_targetContext)
}

func (s *ExecutestmtContext) AS() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserAS, 0)
}

func (s *ExecutestmtContext) Opt_with_data() IOpt_with_dataContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOpt_with_dataContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOpt_with_dataContext)
}

func (s *ExecutestmtContext) IF_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserIF_P, 0)
}

func (s *ExecutestmtContext) NOT() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserNOT, 0)
}

func (s *ExecutestmtContext) EXISTS() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserEXISTS, 0)
}

func (s *ExecutestmtContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *ExecutestmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *ExecutestmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterExecutestmt(s)
	}
}

func (s *ExecutestmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitExecutestmt(s)
	}
}

func (s *ExecutestmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitExecutestmt(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Executestmt() (localctx IExecutestmtContext) {
	localctx = NewExecutestmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 896, PostgreSQLParserRULE_executestmt)
	p.SetState(7639)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 379, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(7612)
			p.Match(PostgreSQLParserEXECUTE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(7613)
			p.Name()
		}
		{
			p.SetState(7614)
			p.Execute_param_clause()
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(7616)
			p.Match(PostgreSQLParserCREATE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(7617)
			p.Opttemp()
		}
		{
			p.SetState(7618)
			p.Match(PostgreSQLParserTABLE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(7619)
			p.Create_as_target()
		}
		{
			p.SetState(7620)
			p.Match(PostgreSQLParserAS)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(7621)
			p.Match(PostgreSQLParserEXECUTE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(7622)
			p.Name()
		}
		{
			p.SetState(7623)
			p.Execute_param_clause()
		}
		{
			p.SetState(7624)
			p.Opt_with_data()
		}

	case 3:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(7626)
			p.Match(PostgreSQLParserCREATE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(7627)
			p.Opttemp()
		}
		{
			p.SetState(7628)
			p.Match(PostgreSQLParserTABLE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(7629)
			p.Match(PostgreSQLParserIF_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(7630)
			p.Match(PostgreSQLParserNOT)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(7631)
			p.Match(PostgreSQLParserEXISTS)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(7632)
			p.Create_as_target()
		}
		{
			p.SetState(7633)
			p.Match(PostgreSQLParserAS)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(7634)
			p.Match(PostgreSQLParserEXECUTE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(7635)
			p.Name()
		}
		{
			p.SetState(7636)
			p.Execute_param_clause()
		}
		{
			p.SetState(7637)
			p.Opt_with_data()
		}

	case antlr.ATNInvalidAltNumber:
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IExecute_param_clauseContext is an interface to support dynamic dispatch.
type IExecute_param_clauseContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	OPEN_PAREN() antlr.TerminalNode
	Expr_list() IExpr_listContext
	CLOSE_PAREN() antlr.TerminalNode

	// IsExecute_param_clauseContext differentiates from other interfaces.
	IsExecute_param_clauseContext()
}

type Execute_param_clauseContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyExecute_param_clauseContext() *Execute_param_clauseContext {
	var p = new(Execute_param_clauseContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_execute_param_clause
	return p
}

func InitEmptyExecute_param_clauseContext(p *Execute_param_clauseContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_execute_param_clause
}

func (*Execute_param_clauseContext) IsExecute_param_clauseContext() {}

func NewExecute_param_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Execute_param_clauseContext {
	var p = new(Execute_param_clauseContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_execute_param_clause

	return p
}

func (s *Execute_param_clauseContext) GetParser() antlr.Parser { return s.parser }

func (s *Execute_param_clauseContext) OPEN_PAREN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserOPEN_PAREN, 0)
}

func (s *Execute_param_clauseContext) Expr_list() IExpr_listContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IExpr_listContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IExpr_listContext)
}

func (s *Execute_param_clauseContext) CLOSE_PAREN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCLOSE_PAREN, 0)
}

func (s *Execute_param_clauseContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Execute_param_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Execute_param_clauseContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterExecute_param_clause(s)
	}
}

func (s *Execute_param_clauseContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitExecute_param_clause(s)
	}
}

func (s *Execute_param_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitExecute_param_clause(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Execute_param_clause() (localctx IExecute_param_clauseContext) {
	localctx = NewExecute_param_clauseContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 898, PostgreSQLParserRULE_execute_param_clause)
	p.SetState(7646)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 380, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(7641)
			p.Match(PostgreSQLParserOPEN_PAREN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(7642)
			p.Expr_list()
		}
		{
			p.SetState(7643)
			p.Match(PostgreSQLParserCLOSE_PAREN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)

	case antlr.ATNInvalidAltNumber:
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IDeallocatestmtContext is an interface to support dynamic dispatch.
type IDeallocatestmtContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	DEALLOCATE() antlr.TerminalNode
	Name() INameContext
	PREPARE() antlr.TerminalNode
	ALL() antlr.TerminalNode

	// IsDeallocatestmtContext differentiates from other interfaces.
	IsDeallocatestmtContext()
}

type DeallocatestmtContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyDeallocatestmtContext() *DeallocatestmtContext {
	var p = new(DeallocatestmtContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_deallocatestmt
	return p
}

func InitEmptyDeallocatestmtContext(p *DeallocatestmtContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_deallocatestmt
}

func (*DeallocatestmtContext) IsDeallocatestmtContext() {}

func NewDeallocatestmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DeallocatestmtContext {
	var p = new(DeallocatestmtContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_deallocatestmt

	return p
}

func (s *DeallocatestmtContext) GetParser() antlr.Parser { return s.parser }

func (s *DeallocatestmtContext) DEALLOCATE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserDEALLOCATE, 0)
}

func (s *DeallocatestmtContext) Name() INameContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(INameContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(INameContext)
}

func (s *DeallocatestmtContext) PREPARE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserPREPARE, 0)
}

func (s *DeallocatestmtContext) ALL() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserALL, 0)
}

func (s *DeallocatestmtContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *DeallocatestmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *DeallocatestmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterDeallocatestmt(s)
	}
}

func (s *DeallocatestmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitDeallocatestmt(s)
	}
}

func (s *DeallocatestmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitDeallocatestmt(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Deallocatestmt() (localctx IDeallocatestmtContext) {
	localctx = NewDeallocatestmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 900, PostgreSQLParserRULE_deallocatestmt)
	p.SetState(7658)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 381, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(7648)
			p.Match(PostgreSQLParserDEALLOCATE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(7649)
			p.Name()
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(7650)
			p.Match(PostgreSQLParserDEALLOCATE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(7651)
			p.Match(PostgreSQLParserPREPARE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(7652)
			p.Name()
		}

	case 3:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(7653)
			p.Match(PostgreSQLParserDEALLOCATE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(7654)
			p.Match(PostgreSQLParserALL)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 4:
		p.EnterOuterAlt(localctx, 4)
		{
			p.SetState(7655)
			p.Match(PostgreSQLParserDEALLOCATE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(7656)
			p.Match(PostgreSQLParserPREPARE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(7657)
			p.Match(PostgreSQLParserALL)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case antlr.ATNInvalidAltNumber:
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IInsertstmtContext is an interface to support dynamic dispatch.
type IInsertstmtContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Opt_with_clause() IOpt_with_clauseContext
	INSERT() antlr.TerminalNode
	INTO() antlr.TerminalNode
	Insert_target() IInsert_targetContext
	Insert_rest() IInsert_restContext
	Opt_on_conflict() IOpt_on_conflictContext
	Returning_clause() IReturning_clauseContext

	// IsInsertstmtContext differentiates from other interfaces.
	IsInsertstmtContext()
}

type InsertstmtContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyInsertstmtContext() *InsertstmtContext {
	var p = new(InsertstmtContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_insertstmt
	return p
}

func InitEmptyInsertstmtContext(p *InsertstmtContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_insertstmt
}

func (*InsertstmtContext) IsInsertstmtContext() {}

func NewInsertstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *InsertstmtContext {
	var p = new(InsertstmtContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_insertstmt

	return p
}

func (s *InsertstmtContext) GetParser() antlr.Parser { return s.parser }

func (s *InsertstmtContext) Opt_with_clause() IOpt_with_clauseContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOpt_with_clauseContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOpt_with_clauseContext)
}

func (s *InsertstmtContext) INSERT() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserINSERT, 0)
}

func (s *InsertstmtContext) INTO() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserINTO, 0)
}

func (s *InsertstmtContext) Insert_target() IInsert_targetContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IInsert_targetContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IInsert_targetContext)
}

func (s *InsertstmtContext) Insert_rest() IInsert_restContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IInsert_restContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IInsert_restContext)
}

func (s *InsertstmtContext) Opt_on_conflict() IOpt_on_conflictContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOpt_on_conflictContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOpt_on_conflictContext)
}

func (s *InsertstmtContext) Returning_clause() IReturning_clauseContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IReturning_clauseContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IReturning_clauseContext)
}

func (s *InsertstmtContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *InsertstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *InsertstmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterInsertstmt(s)
	}
}

func (s *InsertstmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitInsertstmt(s)
	}
}

func (s *InsertstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitInsertstmt(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Insertstmt() (localctx IInsertstmtContext) {
	localctx = NewInsertstmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 902, PostgreSQLParserRULE_insertstmt)
	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(7660)
		p.Opt_with_clause()
	}
	{
		p.SetState(7661)
		p.Match(PostgreSQLParserINSERT)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(7662)
		p.Match(PostgreSQLParserINTO)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(7663)
		p.Insert_target()
	}
	{
		p.SetState(7664)
		p.Insert_rest()
	}
	{
		p.SetState(7665)
		p.Opt_on_conflict()
	}
	{
		p.SetState(7666)
		p.Returning_clause()
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IInsert_targetContext is an interface to support dynamic dispatch.
type IInsert_targetContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Qualified_name() IQualified_nameContext
	AS() antlr.TerminalNode
	Colid() IColidContext

	// IsInsert_targetContext differentiates from other interfaces.
	IsInsert_targetContext()
}

type Insert_targetContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyInsert_targetContext() *Insert_targetContext {
	var p = new(Insert_targetContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_insert_target
	return p
}

func InitEmptyInsert_targetContext(p *Insert_targetContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_insert_target
}

func (*Insert_targetContext) IsInsert_targetContext() {}

func NewInsert_targetContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Insert_targetContext {
	var p = new(Insert_targetContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_insert_target

	return p
}

func (s *Insert_targetContext) GetParser() antlr.Parser { return s.parser }

func (s *Insert_targetContext) Qualified_name() IQualified_nameContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IQualified_nameContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IQualified_nameContext)
}

func (s *Insert_targetContext) AS() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserAS, 0)
}

func (s *Insert_targetContext) Colid() IColidContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IColidContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IColidContext)
}

func (s *Insert_targetContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Insert_targetContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Insert_targetContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterInsert_target(s)
	}
}

func (s *Insert_targetContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitInsert_target(s)
	}
}

func (s *Insert_targetContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitInsert_target(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Insert_target() (localctx IInsert_targetContext) {
	localctx = NewInsert_targetContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 904, PostgreSQLParserRULE_insert_target)
	var _la int

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(7668)
		p.Qualified_name()
	}
	p.SetState(7671)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}
	_la = p.GetTokenStream().LA(1)

	if _la == PostgreSQLParserAS {
		{
			p.SetState(7669)
			p.Match(PostgreSQLParserAS)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(7670)
			p.Colid()
		}

	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IInsert_restContext is an interface to support dynamic dispatch.
type IInsert_restContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Selectstmt() ISelectstmtContext
	OVERRIDING() antlr.TerminalNode
	Override_kind() IOverride_kindContext
	VALUE_P() antlr.TerminalNode
	OPEN_PAREN() antlr.TerminalNode
	Insert_column_list() IInsert_column_listContext
	CLOSE_PAREN() antlr.TerminalNode
	DEFAULT() antlr.TerminalNode
	VALUES() antlr.TerminalNode

	// IsInsert_restContext differentiates from other interfaces.
	IsInsert_restContext()
}

type Insert_restContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyInsert_restContext() *Insert_restContext {
	var p = new(Insert_restContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_insert_rest
	return p
}

func InitEmptyInsert_restContext(p *Insert_restContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_insert_rest
}

func (*Insert_restContext) IsInsert_restContext() {}

func NewInsert_restContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Insert_restContext {
	var p = new(Insert_restContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_insert_rest

	return p
}

func (s *Insert_restContext) GetParser() antlr.Parser { return s.parser }

func (s *Insert_restContext) Selectstmt() ISelectstmtContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ISelectstmtContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ISelectstmtContext)
}

func (s *Insert_restContext) OVERRIDING() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserOVERRIDING, 0)
}

func (s *Insert_restContext) Override_kind() IOverride_kindContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOverride_kindContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOverride_kindContext)
}

func (s *Insert_restContext) VALUE_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserVALUE_P, 0)
}

func (s *Insert_restContext) OPEN_PAREN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserOPEN_PAREN, 0)
}

func (s *Insert_restContext) Insert_column_list() IInsert_column_listContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IInsert_column_listContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IInsert_column_listContext)
}

func (s *Insert_restContext) CLOSE_PAREN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCLOSE_PAREN, 0)
}

func (s *Insert_restContext) DEFAULT() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserDEFAULT, 0)
}

func (s *Insert_restContext) VALUES() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserVALUES, 0)
}

func (s *Insert_restContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Insert_restContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Insert_restContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterInsert_rest(s)
	}
}

func (s *Insert_restContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitInsert_rest(s)
	}
}

func (s *Insert_restContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitInsert_rest(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Insert_rest() (localctx IInsert_restContext) {
	localctx = NewInsert_restContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 906, PostgreSQLParserRULE_insert_rest)
	var _la int

	p.SetState(7692)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 384, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(7673)
			p.Selectstmt()
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(7674)
			p.Match(PostgreSQLParserOVERRIDING)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(7675)
			p.Override_kind()
		}
		{
			p.SetState(7676)
			p.Match(PostgreSQLParserVALUE_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(7677)
			p.Selectstmt()
		}

	case 3:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(7679)
			p.Match(PostgreSQLParserOPEN_PAREN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(7680)
			p.Insert_column_list()
		}
		{
			p.SetState(7681)
			p.Match(PostgreSQLParserCLOSE_PAREN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		p.SetState(7686)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}
		_la = p.GetTokenStream().LA(1)

		if _la == PostgreSQLParserOVERRIDING {
			{
				p.SetState(7682)
				p.Match(PostgreSQLParserOVERRIDING)
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}
			{
				p.SetState(7683)
				p.Override_kind()
			}
			{
				p.SetState(7684)
				p.Match(PostgreSQLParserVALUE_P)
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}

		}
		{
			p.SetState(7688)
			p.Selectstmt()
		}

	case 4:
		p.EnterOuterAlt(localctx, 4)
		{
			p.SetState(7690)
			p.Match(PostgreSQLParserDEFAULT)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(7691)
			p.Match(PostgreSQLParserVALUES)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case antlr.ATNInvalidAltNumber:
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IOverride_kindContext is an interface to support dynamic dispatch.
type IOverride_kindContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	USER() antlr.TerminalNode
	SYSTEM_P() antlr.TerminalNode

	// IsOverride_kindContext differentiates from other interfaces.
	IsOverride_kindContext()
}

type Override_kindContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyOverride_kindContext() *Override_kindContext {
	var p = new(Override_kindContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_override_kind
	return p
}

func InitEmptyOverride_kindContext(p *Override_kindContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_override_kind
}

func (*Override_kindContext) IsOverride_kindContext() {}

func NewOverride_kindContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Override_kindContext {
	var p = new(Override_kindContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_override_kind

	return p
}

func (s *Override_kindContext) GetParser() antlr.Parser { return s.parser }

func (s *Override_kindContext) USER() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserUSER, 0)
}

func (s *Override_kindContext) SYSTEM_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserSYSTEM_P, 0)
}

func (s *Override_kindContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Override_kindContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Override_kindContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterOverride_kind(s)
	}
}

func (s *Override_kindContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitOverride_kind(s)
	}
}

func (s *Override_kindContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitOverride_kind(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Override_kind() (localctx IOverride_kindContext) {
	localctx = NewOverride_kindContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 908, PostgreSQLParserRULE_override_kind)
	var _la int

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(7694)
		_la = p.GetTokenStream().LA(1)

		if !(_la == PostgreSQLParserUSER || _la == PostgreSQLParserSYSTEM_P) {
			p.GetErrorHandler().RecoverInline(p)
		} else {
			p.GetErrorHandler().ReportMatch(p)
			p.Consume()
		}
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IInsert_column_listContext is an interface to support dynamic dispatch.
type IInsert_column_listContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	AllInsert_column_item() []IInsert_column_itemContext
	Insert_column_item(i int) IInsert_column_itemContext
	AllCOMMA() []antlr.TerminalNode
	COMMA(i int) antlr.TerminalNode

	// IsInsert_column_listContext differentiates from other interfaces.
	IsInsert_column_listContext()
}

type Insert_column_listContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyInsert_column_listContext() *Insert_column_listContext {
	var p = new(Insert_column_listContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_insert_column_list
	return p
}

func InitEmptyInsert_column_listContext(p *Insert_column_listContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_insert_column_list
}

func (*Insert_column_listContext) IsInsert_column_listContext() {}

func NewInsert_column_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Insert_column_listContext {
	var p = new(Insert_column_listContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_insert_column_list

	return p
}

func (s *Insert_column_listContext) GetParser() antlr.Parser { return s.parser }

func (s *Insert_column_listContext) AllInsert_column_item() []IInsert_column_itemContext {
	children := s.GetChildren()
	len := 0
	for _, ctx := range children {
		if _, ok := ctx.(IInsert_column_itemContext); ok {
			len++
		}
	}

	tst := make([]IInsert_column_itemContext, len)
	i := 0
	for _, ctx := range children {
		if t, ok := ctx.(IInsert_column_itemContext); ok {
			tst[i] = t.(IInsert_column_itemContext)
			i++
		}
	}

	return tst
}

func (s *Insert_column_listContext) Insert_column_item(i int) IInsert_column_itemContext {
	var t antlr.RuleContext
	j := 0
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IInsert_column_itemContext); ok {
			if j == i {
				t = ctx.(antlr.RuleContext)
				break
			}
			j++
		}
	}

	if t == nil {
		return nil
	}

	return t.(IInsert_column_itemContext)
}

func (s *Insert_column_listContext) AllCOMMA() []antlr.TerminalNode {
	return s.GetTokens(PostgreSQLParserCOMMA)
}

func (s *Insert_column_listContext) COMMA(i int) antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCOMMA, i)
}

func (s *Insert_column_listContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Insert_column_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Insert_column_listContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterInsert_column_list(s)
	}
}

func (s *Insert_column_listContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitInsert_column_list(s)
	}
}

func (s *Insert_column_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitInsert_column_list(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Insert_column_list() (localctx IInsert_column_listContext) {
	localctx = NewInsert_column_listContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 910, PostgreSQLParserRULE_insert_column_list)
	var _la int

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(7696)
		p.Insert_column_item()
	}
	p.SetState(7701)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}
	_la = p.GetTokenStream().LA(1)

	for _la == PostgreSQLParserCOMMA {
		{
			p.SetState(7697)
			p.Match(PostgreSQLParserCOMMA)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(7698)
			p.Insert_column_item()
		}

		p.SetState(7703)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}
		_la = p.GetTokenStream().LA(1)
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IInsert_column_itemContext is an interface to support dynamic dispatch.
type IInsert_column_itemContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Colid() IColidContext
	Opt_indirection() IOpt_indirectionContext

	// IsInsert_column_itemContext differentiates from other interfaces.
	IsInsert_column_itemContext()
}

type Insert_column_itemContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyInsert_column_itemContext() *Insert_column_itemContext {
	var p = new(Insert_column_itemContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_insert_column_item
	return p
}

func InitEmptyInsert_column_itemContext(p *Insert_column_itemContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_insert_column_item
}

func (*Insert_column_itemContext) IsInsert_column_itemContext() {}

func NewInsert_column_itemContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Insert_column_itemContext {
	var p = new(Insert_column_itemContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_insert_column_item

	return p
}

func (s *Insert_column_itemContext) GetParser() antlr.Parser { return s.parser }

func (s *Insert_column_itemContext) Colid() IColidContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IColidContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IColidContext)
}

func (s *Insert_column_itemContext) Opt_indirection() IOpt_indirectionContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOpt_indirectionContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOpt_indirectionContext)
}

func (s *Insert_column_itemContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Insert_column_itemContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Insert_column_itemContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterInsert_column_item(s)
	}
}

func (s *Insert_column_itemContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitInsert_column_item(s)
	}
}

func (s *Insert_column_itemContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitInsert_column_item(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Insert_column_item() (localctx IInsert_column_itemContext) {
	localctx = NewInsert_column_itemContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 912, PostgreSQLParserRULE_insert_column_item)
	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(7704)
		p.Colid()
	}
	{
		p.SetState(7705)
		p.Opt_indirection()
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IOpt_on_conflictContext is an interface to support dynamic dispatch.
type IOpt_on_conflictContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	ON() antlr.TerminalNode
	CONFLICT() antlr.TerminalNode
	Opt_conf_expr() IOpt_conf_exprContext
	DO() antlr.TerminalNode
	UPDATE() antlr.TerminalNode
	SET() antlr.TerminalNode
	Set_clause_list() ISet_clause_listContext
	Where_clause() IWhere_clauseContext
	NOTHING() antlr.TerminalNode

	// IsOpt_on_conflictContext differentiates from other interfaces.
	IsOpt_on_conflictContext()
}

type Opt_on_conflictContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyOpt_on_conflictContext() *Opt_on_conflictContext {
	var p = new(Opt_on_conflictContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opt_on_conflict
	return p
}

func InitEmptyOpt_on_conflictContext(p *Opt_on_conflictContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opt_on_conflict
}

func (*Opt_on_conflictContext) IsOpt_on_conflictContext() {}

func NewOpt_on_conflictContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_on_conflictContext {
	var p = new(Opt_on_conflictContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_opt_on_conflict

	return p
}

func (s *Opt_on_conflictContext) GetParser() antlr.Parser { return s.parser }

func (s *Opt_on_conflictContext) ON() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserON, 0)
}

func (s *Opt_on_conflictContext) CONFLICT() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCONFLICT, 0)
}

func (s *Opt_on_conflictContext) Opt_conf_expr() IOpt_conf_exprContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOpt_conf_exprContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOpt_conf_exprContext)
}

func (s *Opt_on_conflictContext) DO() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserDO, 0)
}

func (s *Opt_on_conflictContext) UPDATE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserUPDATE, 0)
}

func (s *Opt_on_conflictContext) SET() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserSET, 0)
}

func (s *Opt_on_conflictContext) Set_clause_list() ISet_clause_listContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ISet_clause_listContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ISet_clause_listContext)
}

func (s *Opt_on_conflictContext) Where_clause() IWhere_clauseContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IWhere_clauseContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IWhere_clauseContext)
}

func (s *Opt_on_conflictContext) NOTHING() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserNOTHING, 0)
}

func (s *Opt_on_conflictContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Opt_on_conflictContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Opt_on_conflictContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterOpt_on_conflict(s)
	}
}

func (s *Opt_on_conflictContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitOpt_on_conflict(s)
	}
}

func (s *Opt_on_conflictContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitOpt_on_conflict(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Opt_on_conflict() (localctx IOpt_on_conflictContext) {
	localctx = NewOpt_on_conflictContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 914, PostgreSQLParserRULE_opt_on_conflict)
	p.SetState(7720)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetTokenStream().LA(1) {
	case PostgreSQLParserON:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(7707)
			p.Match(PostgreSQLParserON)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(7708)
			p.Match(PostgreSQLParserCONFLICT)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(7709)
			p.Opt_conf_expr()
		}
		{
			p.SetState(7710)
			p.Match(PostgreSQLParserDO)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		p.SetState(7717)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}

		switch p.GetTokenStream().LA(1) {
		case PostgreSQLParserUPDATE:
			{
				p.SetState(7711)
				p.Match(PostgreSQLParserUPDATE)
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}
			{
				p.SetState(7712)
				p.Match(PostgreSQLParserSET)
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}
			{
				p.SetState(7713)
				p.Set_clause_list()
			}
			{
				p.SetState(7714)
				p.Where_clause()
			}

		case PostgreSQLParserNOTHING:
			{
				p.SetState(7716)
				p.Match(PostgreSQLParserNOTHING)
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}

		default:
			p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
			goto errorExit
		}

	case PostgreSQLParserEOF, PostgreSQLParserOPEN_PAREN, PostgreSQLParserCLOSE_PAREN, PostgreSQLParserSEMI, PostgreSQLParserANALYSE, PostgreSQLParserANALYZE, PostgreSQLParserCREATE, PostgreSQLParserDO, PostgreSQLParserFETCH, PostgreSQLParserGRANT, PostgreSQLParserINTO, PostgreSQLParserRETURNING, PostgreSQLParserSELECT, PostgreSQLParserTABLE, PostgreSQLParserWITH, PostgreSQLParserABORT_P, PostgreSQLParserALTER, PostgreSQLParserBEGIN_P, PostgreSQLParserCHECKPOINT, PostgreSQLParserCLOSE, PostgreSQLParserCLUSTER, PostgreSQLParserCOMMENT, PostgreSQLParserCOMMIT, PostgreSQLParserCOPY, PostgreSQLParserDEALLOCATE, PostgreSQLParserDECLARE, PostgreSQLParserDELETE_P, PostgreSQLParserDISCARD, PostgreSQLParserDROP, PostgreSQLParserEXECUTE, PostgreSQLParserEXPLAIN, PostgreSQLParserINSERT, PostgreSQLParserLISTEN, PostgreSQLParserLOAD, PostgreSQLParserLOCK_P, PostgreSQLParserMERGE, PostgreSQLParserMOVE, PostgreSQLParserNOTIFY, PostgreSQLParserPREPARE, PostgreSQLParserREASSIGN, PostgreSQLParserREFRESH, PostgreSQLParserREINDEX, PostgreSQLParserRELEASE, PostgreSQLParserRESET, PostgreSQLParserREVOKE, PostgreSQLParserROLLBACK, PostgreSQLParserSAVEPOINT, PostgreSQLParserSECURITY, PostgreSQLParserSET, PostgreSQLParserSHOW, PostgreSQLParserSTART, PostgreSQLParserTRUNCATE, PostgreSQLParserUNLISTEN, PostgreSQLParserUPDATE, PostgreSQLParserVACUUM, PostgreSQLParserVALUES, PostgreSQLParserCALL, PostgreSQLParserIMPORT_P, PostgreSQLParserEND_P, PostgreSQLParserLOOP, PostgreSQLParserMetaCommand:
		p.EnterOuterAlt(localctx, 2)

	default:
		p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IOpt_conf_exprContext is an interface to support dynamic dispatch.
type IOpt_conf_exprContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	OPEN_PAREN() antlr.TerminalNode
	Index_params() IIndex_paramsContext
	CLOSE_PAREN() antlr.TerminalNode
	Where_clause() IWhere_clauseContext
	ON() antlr.TerminalNode
	CONSTRAINT() antlr.TerminalNode
	Name() INameContext

	// IsOpt_conf_exprContext differentiates from other interfaces.
	IsOpt_conf_exprContext()
}

type Opt_conf_exprContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyOpt_conf_exprContext() *Opt_conf_exprContext {
	var p = new(Opt_conf_exprContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opt_conf_expr
	return p
}

func InitEmptyOpt_conf_exprContext(p *Opt_conf_exprContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opt_conf_expr
}

func (*Opt_conf_exprContext) IsOpt_conf_exprContext() {}

func NewOpt_conf_exprContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_conf_exprContext {
	var p = new(Opt_conf_exprContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_opt_conf_expr

	return p
}

func (s *Opt_conf_exprContext) GetParser() antlr.Parser { return s.parser }

func (s *Opt_conf_exprContext) OPEN_PAREN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserOPEN_PAREN, 0)
}

func (s *Opt_conf_exprContext) Index_params() IIndex_paramsContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IIndex_paramsContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IIndex_paramsContext)
}

func (s *Opt_conf_exprContext) CLOSE_PAREN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCLOSE_PAREN, 0)
}

func (s *Opt_conf_exprContext) Where_clause() IWhere_clauseContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IWhere_clauseContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IWhere_clauseContext)
}

func (s *Opt_conf_exprContext) ON() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserON, 0)
}

func (s *Opt_conf_exprContext) CONSTRAINT() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCONSTRAINT, 0)
}

func (s *Opt_conf_exprContext) Name() INameContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(INameContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(INameContext)
}

func (s *Opt_conf_exprContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Opt_conf_exprContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Opt_conf_exprContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterOpt_conf_expr(s)
	}
}

func (s *Opt_conf_exprContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitOpt_conf_expr(s)
	}
}

func (s *Opt_conf_exprContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitOpt_conf_expr(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Opt_conf_expr() (localctx IOpt_conf_exprContext) {
	localctx = NewOpt_conf_exprContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 916, PostgreSQLParserRULE_opt_conf_expr)
	p.SetState(7731)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetTokenStream().LA(1) {
	case PostgreSQLParserOPEN_PAREN:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(7722)
			p.Match(PostgreSQLParserOPEN_PAREN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(7723)
			p.Index_params()
		}
		{
			p.SetState(7724)
			p.Match(PostgreSQLParserCLOSE_PAREN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(7725)
			p.Where_clause()
		}

	case PostgreSQLParserON:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(7727)
			p.Match(PostgreSQLParserON)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(7728)
			p.Match(PostgreSQLParserCONSTRAINT)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(7729)
			p.Name()
		}

	case PostgreSQLParserDO:
		p.EnterOuterAlt(localctx, 3)

	default:
		p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IReturning_clauseContext is an interface to support dynamic dispatch.
type IReturning_clauseContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	RETURNING() antlr.TerminalNode
	Target_list() ITarget_listContext

	// IsReturning_clauseContext differentiates from other interfaces.
	IsReturning_clauseContext()
}

type Returning_clauseContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyReturning_clauseContext() *Returning_clauseContext {
	var p = new(Returning_clauseContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_returning_clause
	return p
}

func InitEmptyReturning_clauseContext(p *Returning_clauseContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_returning_clause
}

func (*Returning_clauseContext) IsReturning_clauseContext() {}

func NewReturning_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Returning_clauseContext {
	var p = new(Returning_clauseContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_returning_clause

	return p
}

func (s *Returning_clauseContext) GetParser() antlr.Parser { return s.parser }

func (s *Returning_clauseContext) RETURNING() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserRETURNING, 0)
}

func (s *Returning_clauseContext) Target_list() ITarget_listContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ITarget_listContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ITarget_listContext)
}

func (s *Returning_clauseContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Returning_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Returning_clauseContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterReturning_clause(s)
	}
}

func (s *Returning_clauseContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitReturning_clause(s)
	}
}

func (s *Returning_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitReturning_clause(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Returning_clause() (localctx IReturning_clauseContext) {
	localctx = NewReturning_clauseContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 918, PostgreSQLParserRULE_returning_clause)
	p.SetState(7736)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetTokenStream().LA(1) {
	case PostgreSQLParserRETURNING:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(7733)
			p.Match(PostgreSQLParserRETURNING)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(7734)
			p.Target_list()
		}

	case PostgreSQLParserEOF, PostgreSQLParserOPEN_PAREN, PostgreSQLParserCLOSE_PAREN, PostgreSQLParserSEMI, PostgreSQLParserANALYSE, PostgreSQLParserANALYZE, PostgreSQLParserCREATE, PostgreSQLParserDO, PostgreSQLParserFETCH, PostgreSQLParserGRANT, PostgreSQLParserINTO, PostgreSQLParserSELECT, PostgreSQLParserTABLE, PostgreSQLParserWITH, PostgreSQLParserABORT_P, PostgreSQLParserALTER, PostgreSQLParserBEGIN_P, PostgreSQLParserCHECKPOINT, PostgreSQLParserCLOSE, PostgreSQLParserCLUSTER, PostgreSQLParserCOMMENT, PostgreSQLParserCOMMIT, PostgreSQLParserCOPY, PostgreSQLParserDEALLOCATE, PostgreSQLParserDECLARE, PostgreSQLParserDELETE_P, PostgreSQLParserDISCARD, PostgreSQLParserDROP, PostgreSQLParserEXECUTE, PostgreSQLParserEXPLAIN, PostgreSQLParserINSERT, PostgreSQLParserLISTEN, PostgreSQLParserLOAD, PostgreSQLParserLOCK_P, PostgreSQLParserMERGE, PostgreSQLParserMOVE, PostgreSQLParserNOTIFY, PostgreSQLParserPREPARE, PostgreSQLParserREASSIGN, PostgreSQLParserREFRESH, PostgreSQLParserREINDEX, PostgreSQLParserRELEASE, PostgreSQLParserRESET, PostgreSQLParserREVOKE, PostgreSQLParserROLLBACK, PostgreSQLParserSAVEPOINT, PostgreSQLParserSECURITY, PostgreSQLParserSET, PostgreSQLParserSHOW, PostgreSQLParserSTART, PostgreSQLParserTRUNCATE, PostgreSQLParserUNLISTEN, PostgreSQLParserUPDATE, PostgreSQLParserVACUUM, PostgreSQLParserVALUES, PostgreSQLParserCALL, PostgreSQLParserIMPORT_P, PostgreSQLParserEND_P, PostgreSQLParserLOOP, PostgreSQLParserMetaCommand:
		p.EnterOuterAlt(localctx, 2)

	default:
		p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IMergestmtContext is an interface to support dynamic dispatch.
type IMergestmtContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	MERGE() antlr.TerminalNode
	AllQualified_name() []IQualified_nameContext
	Qualified_name(i int) IQualified_nameContext
	USING() antlr.TerminalNode
	ON() antlr.TerminalNode
	A_expr() IA_exprContext
	Select_with_parens() ISelect_with_parensContext
	Merge_insert_clause() IMerge_insert_clauseContext
	Merge_update_clause() IMerge_update_clauseContext
	INTO() antlr.TerminalNode
	AllAlias_clause() []IAlias_clauseContext
	Alias_clause(i int) IAlias_clauseContext
	Merge_delete_clause() IMerge_delete_clauseContext

	// IsMergestmtContext differentiates from other interfaces.
	IsMergestmtContext()
}

type MergestmtContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyMergestmtContext() *MergestmtContext {
	var p = new(MergestmtContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_mergestmt
	return p
}

func InitEmptyMergestmtContext(p *MergestmtContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_mergestmt
}

func (*MergestmtContext) IsMergestmtContext() {}

func NewMergestmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *MergestmtContext {
	var p = new(MergestmtContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_mergestmt

	return p
}

func (s *MergestmtContext) GetParser() antlr.Parser { return s.parser }

func (s *MergestmtContext) MERGE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserMERGE, 0)
}

func (s *MergestmtContext) AllQualified_name() []IQualified_nameContext {
	children := s.GetChildren()
	len := 0
	for _, ctx := range children {
		if _, ok := ctx.(IQualified_nameContext); ok {
			len++
		}
	}

	tst := make([]IQualified_nameContext, len)
	i := 0
	for _, ctx := range children {
		if t, ok := ctx.(IQualified_nameContext); ok {
			tst[i] = t.(IQualified_nameContext)
			i++
		}
	}

	return tst
}

func (s *MergestmtContext) Qualified_name(i int) IQualified_nameContext {
	var t antlr.RuleContext
	j := 0
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IQualified_nameContext); ok {
			if j == i {
				t = ctx.(antlr.RuleContext)
				break
			}
			j++
		}
	}

	if t == nil {
		return nil
	}

	return t.(IQualified_nameContext)
}

func (s *MergestmtContext) USING() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserUSING, 0)
}

func (s *MergestmtContext) ON() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserON, 0)
}

func (s *MergestmtContext) A_expr() IA_exprContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IA_exprContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IA_exprContext)
}

func (s *MergestmtContext) Select_with_parens() ISelect_with_parensContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ISelect_with_parensContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ISelect_with_parensContext)
}

func (s *MergestmtContext) Merge_insert_clause() IMerge_insert_clauseContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IMerge_insert_clauseContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IMerge_insert_clauseContext)
}

func (s *MergestmtContext) Merge_update_clause() IMerge_update_clauseContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IMerge_update_clauseContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IMerge_update_clauseContext)
}

func (s *MergestmtContext) INTO() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserINTO, 0)
}

func (s *MergestmtContext) AllAlias_clause() []IAlias_clauseContext {
	children := s.GetChildren()
	len := 0
	for _, ctx := range children {
		if _, ok := ctx.(IAlias_clauseContext); ok {
			len++
		}
	}

	tst := make([]IAlias_clauseContext, len)
	i := 0
	for _, ctx := range children {
		if t, ok := ctx.(IAlias_clauseContext); ok {
			tst[i] = t.(IAlias_clauseContext)
			i++
		}
	}

	return tst
}

func (s *MergestmtContext) Alias_clause(i int) IAlias_clauseContext {
	var t antlr.RuleContext
	j := 0
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IAlias_clauseContext); ok {
			if j == i {
				t = ctx.(antlr.RuleContext)
				break
			}
			j++
		}
	}

	if t == nil {
		return nil
	}

	return t.(IAlias_clauseContext)
}

func (s *MergestmtContext) Merge_delete_clause() IMerge_delete_clauseContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IMerge_delete_clauseContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IMerge_delete_clauseContext)
}

func (s *MergestmtContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *MergestmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *MergestmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterMergestmt(s)
	}
}

func (s *MergestmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitMergestmt(s)
	}
}

func (s *MergestmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitMergestmt(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Mergestmt() (localctx IMergestmtContext) {
	localctx = NewMergestmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 920, PostgreSQLParserRULE_mergestmt)
	var _la int

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(7738)
		p.Match(PostgreSQLParserMERGE)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	p.SetState(7740)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}
	_la = p.GetTokenStream().LA(1)

	if _la == PostgreSQLParserINTO {
		{
			p.SetState(7739)
			p.Match(PostgreSQLParserINTO)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	}
	{
		p.SetState(7742)
		p.Qualified_name()
	}
	p.SetState(7744)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}
	_la = p.GetTokenStream().LA(1)

	if ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&2459027080864595968) != 0) || ((int64((_la-92)) & ^0x3f) == 0 && ((int64(1)<<(_la-92))&-113665638399) != 0) || ((int64((_la-156)) & ^0x3f) == 0 && ((int64(1)<<(_la-156))&-1) != 0) || ((int64((_la-220)) & ^0x3f) == 0 && ((int64(1)<<(_la-220))&-9663676417) != 0) || ((int64((_la-284)) & ^0x3f) == 0 && ((int64(1)<<(_la-284))&-1) != 0) || ((int64((_la-348)) & ^0x3f) == 0 && ((int64(1)<<(_la-348))&-1) != 0) || ((int64((_la-412)) & ^0x3f) == 0 && ((int64(1)<<(_la-412))&-1152925902653358081) != 0) || ((int64((_la-476)) & ^0x3f) == 0 && ((int64(1)<<(_la-476))&-8796764110849) != 0) || ((int64((_la-540)) & ^0x3f) == 0 && ((int64(1)<<(_la-540))&-1) != 0) || ((int64((_la-604)) & ^0x3f) == 0 && ((int64(1)<<(_la-604))&432345718846390271) != 0) {
		{
			p.SetState(7743)
			p.Alias_clause()
		}

	}
	{
		p.SetState(7746)
		p.Match(PostgreSQLParserUSING)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	p.SetState(7749)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetTokenStream().LA(1) {
	case PostgreSQLParserOPEN_PAREN:
		{
			p.SetState(7747)
			p.Select_with_parens()
		}

	case PostgreSQLParserAND, PostgreSQLParserARRAY, PostgreSQLParserCOLLATE, PostgreSQLParserCOLUMN, PostgreSQLParserCONSTRAINT, PostgreSQLParserDEFAULT, PostgreSQLParserDO, PostgreSQLParserFETCH, PostgreSQLParserTABLE, PostgreSQLParserIS, PostgreSQLParserLEFT, PostgreSQLParserOUTER_P, PostgreSQLParserOVER, PostgreSQLParserRIGHT, PostgreSQLParserABORT_P, PostgreSQLParserABSOLUTE_P, PostgreSQLParserACCESS, PostgreSQLParserACTION, PostgreSQLParserADD_P, PostgreSQLParserADMIN, PostgreSQLParserAFTER, PostgreSQLParserAGGREGATE, PostgreSQLParserALSO, PostgreSQLParserALTER, PostgreSQLParserALWAYS, PostgreSQLParserASSERTION, PostgreSQLParserASSIGNMENT, PostgreSQLParserAT, PostgreSQLParserATTRIBUTE, PostgreSQLParserBACKWARD, PostgreSQLParserBEFORE, PostgreSQLParserBEGIN_P, PostgreSQLParserBY, PostgreSQLParserCACHE, PostgreSQLParserCALLED, PostgreSQLParserCASCADE, PostgreSQLParserCASCADED, PostgreSQLParserCATALOG, PostgreSQLParserCHAIN, PostgreSQLParserCHARACTERISTICS, PostgreSQLParserCHECKPOINT, PostgreSQLParserCLASS, PostgreSQLParserCLOSE, PostgreSQLParserCLUSTER, PostgreSQLParserCOMMENT, PostgreSQLParserCOMMENTS, PostgreSQLParserCOMMIT, PostgreSQLParserCOMMITTED, PostgreSQLParserCONFIGURATION, PostgreSQLParserCONNECTION, PostgreSQLParserCONSTRAINTS, PostgreSQLParserCONTENT_P, PostgreSQLParserCONTINUE_P, PostgreSQLParserCONVERSION_P, PostgreSQLParserCOPY, PostgreSQLParserCOST, PostgreSQLParserCSV, PostgreSQLParserCURSOR, PostgreSQLParserCYCLE, PostgreSQLParserDATA_P, PostgreSQLParserDATABASE, PostgreSQLParserDAY_P, PostgreSQLParserDEALLOCATE, PostgreSQLParserDECLARE, PostgreSQLParserDEFAULTS, PostgreSQLParserDEFERRED, PostgreSQLParserDEFINER, PostgreSQLParserDELETE_P, PostgreSQLParserDELIMITER, PostgreSQLParserDELIMITERS, PostgreSQLParserDICTIONARY, PostgreSQLParserDISABLE_P, PostgreSQLParserDISCARD, PostgreSQLParserDOCUMENT_P, PostgreSQLParserDOMAIN_P, PostgreSQLParserDOUBLE_P, PostgreSQLParserDROP, PostgreSQLParserEACH, PostgreSQLParserENABLE_P, PostgreSQLParserENCODING, PostgreSQLParserENCRYPTED, PostgreSQLParserENUM_P, PostgreSQLParserESCAPE, PostgreSQLParserEVENT, PostgreSQLParserEXCLUDE, PostgreSQLParserEXCLUDING, PostgreSQLParserEXCLUSIVE, PostgreSQLParserEXECUTE, PostgreSQLParserEXPLAIN, PostgreSQLParserEXTENSION, PostgreSQLParserEXTERNAL, PostgreSQLParserFAMILY, PostgreSQLParserFIRST_P, PostgreSQLParserFOLLOWING, PostgreSQLParserFORCE, PostgreSQLParserFORWARD, PostgreSQLParserFUNCTION, PostgreSQLParserFUNCTIONS, PostgreSQLParserGLOBAL, PostgreSQLParserGRANTED, PostgreSQLParserHANDLER, PostgreSQLParserHEADER_P, PostgreSQLParserHOLD, PostgreSQLParserHOUR_P, PostgreSQLParserIDENTITY_P, PostgreSQLParserIF_P, PostgreSQLParserIMMEDIATE, PostgreSQLParserIMMUTABLE, PostgreSQLParserIMPLICIT_P, PostgreSQLParserINCLUDING, PostgreSQLParserINCREMENT, PostgreSQLParserINDEX, PostgreSQLParserINDEXES, PostgreSQLParserINHERIT, PostgreSQLParserINHERITS, PostgreSQLParserINLINE_P, PostgreSQLParserINSENSITIVE, PostgreSQLParserINSERT, PostgreSQLParserINSTEAD, PostgreSQLParserINVOKER, PostgreSQLParserISOLATION, PostgreSQLParserKEY, PostgreSQLParserLABEL, PostgreSQLParserLANGUAGE, PostgreSQLParserLARGE_P, PostgreSQLParserLAST_P, PostgreSQLParserLEAKPROOF, PostgreSQLParserLEVEL, PostgreSQLParserLISTEN, PostgreSQLParserLOAD, PostgreSQLParserLOCAL, PostgreSQLParserLOCATION, PostgreSQLParserLOCK_P, PostgreSQLParserMAPPING, PostgreSQLParserMATCH, PostgreSQLParserMATERIALIZED, PostgreSQLParserMAXVALUE, PostgreSQLParserMINUTE_P, PostgreSQLParserMINVALUE, PostgreSQLParserMODE, PostgreSQLParserMONTH_P, PostgreSQLParserMOVE, PostgreSQLParserNAME_P, PostgreSQLParserNAMES, PostgreSQLParserNEXT, PostgreSQLParserNO, PostgreSQLParserNOTHING, PostgreSQLParserNOTIFY, PostgreSQLParserNOWAIT, PostgreSQLParserNULLS_P, PostgreSQLParserOBJECT_P, PostgreSQLParserOF, PostgreSQLParserOFF, PostgreSQLParserOIDS, PostgreSQLParserOPERATOR, PostgreSQLParserOPTION, PostgreSQLParserOPTIONS, PostgreSQLParserOWNED, PostgreSQLParserOWNER, PostgreSQLParserPARSER, PostgreSQLParserPARTIAL, PostgreSQLParserPARTITION, PostgreSQLParserPASSING, PostgreSQLParserPASSWORD, PostgreSQLParserPLANS, PostgreSQLParserPRECEDING, PostgreSQLParserPREPARE, PostgreSQLParserPREPARED, PostgreSQLParserPRESERVE, PostgreSQLParserPRIOR, PostgreSQLParserPRIVILEGES, PostgreSQLParserPROCEDURAL, PostgreSQLParserPROCEDURE, PostgreSQLParserPROGRAM, PostgreSQLParserQUOTE, PostgreSQLParserRANGE, PostgreSQLParserREAD, PostgreSQLParserREASSIGN, PostgreSQLParserRECHECK, PostgreSQLParserRECURSIVE, PostgreSQLParserREF, PostgreSQLParserREFRESH, PostgreSQLParserREINDEX, PostgreSQLParserRELATIVE_P, PostgreSQLParserRELEASE, PostgreSQLParserRENAME, PostgreSQLParserREPEATABLE, PostgreSQLParserREPLACE, PostgreSQLParserREPLICA, PostgreSQLParserRESET, PostgreSQLParserRESTART, PostgreSQLParserRESTRICT, PostgreSQLParserRETURNS, PostgreSQLParserREVOKE, PostgreSQLParserROLE, PostgreSQLParserROLLBACK, PostgreSQLParserROWS, PostgreSQLParserRULE, PostgreSQLParserSAVEPOINT, PostgreSQLParserSCHEMA, PostgreSQLParserSCROLL, PostgreSQLParserSEARCH, PostgreSQLParserSECOND_P, PostgreSQLParserSECURITY, PostgreSQLParserSEQUENCE, PostgreSQLParserSEQUENCES, PostgreSQLParserSERIALIZABLE, PostgreSQLParserSERVER, PostgreSQLParserSESSION, PostgreSQLParserSET, PostgreSQLParserSHARE, PostgreSQLParserSHOW, PostgreSQLParserSIMPLE, PostgreSQLParserSNAPSHOT, PostgreSQLParserSTABLE, PostgreSQLParserSTANDALONE_P, PostgreSQLParserSTART, PostgreSQLParserSTATEMENT, PostgreSQLParserSTATISTICS, PostgreSQLParserSTDIN, PostgreSQLParserSTDOUT, PostgreSQLParserSTORAGE, PostgreSQLParserSTRICT_P, PostgreSQLParserSTRIP_P, PostgreSQLParserSYSID, PostgreSQLParserSYSTEM_P, PostgreSQLParserTABLES, PostgreSQLParserTABLESPACE, PostgreSQLParserTEMP, PostgreSQLParserTEMPLATE, PostgreSQLParserTEMPORARY, PostgreSQLParserTEXT_P, PostgreSQLParserTRANSACTION, PostgreSQLParserTRIGGER, PostgreSQLParserTRUNCATE, PostgreSQLParserTRUSTED, PostgreSQLParserTYPE_P, PostgreSQLParserTYPES_P, PostgreSQLParserUNBOUNDED, PostgreSQLParserUNCOMMITTED, PostgreSQLParserUNENCRYPTED, PostgreSQLParserUNKNOWN, PostgreSQLParserUNLISTEN, PostgreSQLParserUNLOGGED, PostgreSQLParserUNTIL, PostgreSQLParserUPDATE, PostgreSQLParserVACUUM, PostgreSQLParserVALID, PostgreSQLParserVALIDATE, PostgreSQLParserVALIDATOR, PostgreSQLParserVARYING, PostgreSQLParserVERSION_P, PostgreSQLParserVIEW, PostgreSQLParserVOLATILE, PostgreSQLParserWHITESPACE_P, PostgreSQLParserWITHOUT, PostgreSQLParserWORK, PostgreSQLParserWRAPPER, PostgreSQLParserWRITE, PostgreSQLParserXML_P, PostgreSQLParserYEAR_P, PostgreSQLParserYES_P, PostgreSQLParserZONE, PostgreSQLParserBETWEEN, PostgreSQLParserBIGINT, PostgreSQLParserBIT, PostgreSQLParserBOOLEAN_P, PostgreSQLParserCHAR_P, PostgreSQLParserCHARACTER, PostgreSQLParserCOALESCE, PostgreSQLParserDEC, PostgreSQLParserDECIMAL_P, PostgreSQLParserEXISTS, PostgreSQLParserEXTRACT, PostgreSQLParserFLOAT_P, PostgreSQLParserGREATEST, PostgreSQLParserINOUT, PostgreSQLParserINT_P, PostgreSQLParserINTEGER, PostgreSQLParserINTERVAL, PostgreSQLParserLEAST, PostgreSQLParserNATIONAL, PostgreSQLParserNCHAR, PostgreSQLParserNONE, PostgreSQLParserNULLIF, PostgreSQLParserNUMERIC, PostgreSQLParserOVERLAY, PostgreSQLParserPOSITION, PostgreSQLParserPRECISION, PostgreSQLParserREAL, PostgreSQLParserROW, PostgreSQLParserSETOF, PostgreSQLParserSMALLINT, PostgreSQLParserSUBSTRING, PostgreSQLParserTIME, PostgreSQLParserTIMESTAMP, PostgreSQLParserTREAT, PostgreSQLParserTRIM, PostgreSQLParserVALUES, PostgreSQLParserVARCHAR, PostgreSQLParserXMLATTRIBUTES, PostgreSQLParserXMLCOMMENT, PostgreSQLParserXMLAGG, PostgreSQLParserXML_IS_WELL_FORMED, PostgreSQLParserXML_IS_WELL_FORMED_DOCUMENT, PostgreSQLParserXML_IS_WELL_FORMED_CONTENT, PostgreSQLParserXPATH, PostgreSQLParserXPATH_EXISTS, PostgreSQLParserXMLCONCAT, PostgreSQLParserXMLELEMENT, PostgreSQLParserXMLEXISTS, PostgreSQLParserXMLFOREST, PostgreSQLParserXMLPARSE, PostgreSQLParserXMLPI, PostgreSQLParserXMLROOT, PostgreSQLParserXMLSERIALIZE, PostgreSQLParserCALL, PostgreSQLParserCURRENT_P, PostgreSQLParserATTACH, PostgreSQLParserDETACH, PostgreSQLParserEXPRESSION, PostgreSQLParserGENERATED, PostgreSQLParserLOGGED, PostgreSQLParserSTORED, PostgreSQLParserINCLUDE, PostgreSQLParserROUTINE, PostgreSQLParserTRANSFORM, PostgreSQLParserIMPORT_P, PostgreSQLParserPOLICY, PostgreSQLParserMETHOD, PostgreSQLParserREFERENCING, PostgreSQLParserNEW, PostgreSQLParserOLD, PostgreSQLParserVALUE_P, PostgreSQLParserSUBSCRIPTION, PostgreSQLParserPUBLICATION, PostgreSQLParserOUT_P, PostgreSQLParserROUTINES, PostgreSQLParserSCHEMAS, PostgreSQLParserPROCEDURES, PostgreSQLParserINPUT_P, PostgreSQLParserSUPPORT, PostgreSQLParserPARALLEL, PostgreSQLParserSQL_P, PostgreSQLParserDEPENDS, PostgreSQLParserOVERRIDING, PostgreSQLParserCONFLICT, PostgreSQLParserSKIP_P, PostgreSQLParserLOCKED, PostgreSQLParserTIES, PostgreSQLParserROLLUP, PostgreSQLParserCUBE, PostgreSQLParserGROUPING, PostgreSQLParserSETS, PostgreSQLParserORDINALITY, PostgreSQLParserXMLTABLE, PostgreSQLParserCOLUMNS, PostgreSQLParserXMLNAMESPACES, PostgreSQLParserROWTYPE, PostgreSQLParserNORMALIZED, PostgreSQLParserWITHIN, PostgreSQLParserFILTER, PostgreSQLParserGROUPS, PostgreSQLParserOTHERS, PostgreSQLParserNFC, PostgreSQLParserNFD, PostgreSQLParserNFKC, PostgreSQLParserNFKD, PostgreSQLParserUESCAPE, PostgreSQLParserVIEWS, PostgreSQLParserNORMALIZE, PostgreSQLParserDUMP, PostgreSQLParserPRINT_STRICT_PARAMS, PostgreSQLParserVARIABLE_CONFLICT, PostgreSQLParserERROR, PostgreSQLParserUSE_VARIABLE, PostgreSQLParserUSE_COLUMN, PostgreSQLParserALIAS, PostgreSQLParserCONSTANT, PostgreSQLParserPERFORM, PostgreSQLParserGET, PostgreSQLParserDIAGNOSTICS, PostgreSQLParserSTACKED, PostgreSQLParserELSIF, PostgreSQLParserREVERSE, PostgreSQLParserSLICE, PostgreSQLParserEXIT, PostgreSQLParserRETURN, PostgreSQLParserQUERY, PostgreSQLParserRAISE, PostgreSQLParserSQLSTATE, PostgreSQLParserDEBUG, PostgreSQLParserLOG, PostgreSQLParserINFO, PostgreSQLParserNOTICE, PostgreSQLParserWARNING, PostgreSQLParserEXCEPTION, PostgreSQLParserASSERT, PostgreSQLParserOPEN, PostgreSQLParserABS, PostgreSQLParserCBRT, PostgreSQLParserCEIL, PostgreSQLParserCEILING, PostgreSQLParserDEGREES, PostgreSQLParserDIV, PostgreSQLParserEXP, PostgreSQLParserFACTORIAL, PostgreSQLParserFLOOR, PostgreSQLParserGCD, PostgreSQLParserLCM, PostgreSQLParserLN, PostgreSQLParserLOG10, PostgreSQLParserMIN_SCALE, PostgreSQLParserMOD, PostgreSQLParserPI, PostgreSQLParserPOWER, PostgreSQLParserRADIANS, PostgreSQLParserROUND, PostgreSQLParserSCALE, PostgreSQLParserSIGN, PostgreSQLParserSQRT, PostgreSQLParserTRIM_SCALE, PostgreSQLParserTRUNC, PostgreSQLParserWIDTH_BUCKET, PostgreSQLParserRANDOM, PostgreSQLParserSETSEED, PostgreSQLParserACOS, PostgreSQLParserACOSD, PostgreSQLParserASIN, PostgreSQLParserASIND, PostgreSQLParserATAN, PostgreSQLParserATAND, PostgreSQLParserATAN2, PostgreSQLParserATAN2D, PostgreSQLParserCOS, PostgreSQLParserCOSD, PostgreSQLParserCOT, PostgreSQLParserCOTD, PostgreSQLParserSIN, PostgreSQLParserSIND, PostgreSQLParserTAN, PostgreSQLParserTAND, PostgreSQLParserSINH, PostgreSQLParserCOSH, PostgreSQLParserTANH, PostgreSQLParserASINH, PostgreSQLParserACOSH, PostgreSQLParserATANH, PostgreSQLParserBIT_LENGTH, PostgreSQLParserCHAR_LENGTH, PostgreSQLParserCHARACTER_LENGTH, PostgreSQLParserLOWER, PostgreSQLParserOCTET_LENGTH, PostgreSQLParserUPPER, PostgreSQLParserASCII, PostgreSQLParserBTRIM, PostgreSQLParserCHR, PostgreSQLParserCONCAT, PostgreSQLParserCONCAT_WS, PostgreSQLParserFORMAT, PostgreSQLParserINITCAP, PostgreSQLParserLENGTH, PostgreSQLParserLPAD, PostgreSQLParserLTRIM, PostgreSQLParserMD5, PostgreSQLParserPARSE_IDENT, PostgreSQLParserPG_CLIENT_ENCODING, PostgreSQLParserQUOTE_IDENT, PostgreSQLParserQUOTE_LITERAL, PostgreSQLParserQUOTE_NULLABLE, PostgreSQLParserREGEXP_COUNT, PostgreSQLParserREGEXP_INSTR, PostgreSQLParserREGEXP_LIKE, PostgreSQLParserREGEXP_MATCH, PostgreSQLParserREGEXP_MATCHES, PostgreSQLParserREGEXP_REPLACE, PostgreSQLParserREGEXP_SPLIT_TO_ARRAY, PostgreSQLParserREGEXP_SPLIT_TO_TABLE, PostgreSQLParserREGEXP_SUBSTR, PostgreSQLParserREPEAT, PostgreSQLParserRPAD, PostgreSQLParserRTRIM, PostgreSQLParserSPLIT_PART, PostgreSQLParserSTARTS_WITH, PostgreSQLParserSTRING_TO_ARRAY, PostgreSQLParserSTRING_TO_TABLE, PostgreSQLParserSTRPOS, PostgreSQLParserSUBSTR, PostgreSQLParserTO_ASCII, PostgreSQLParserTO_HEX, PostgreSQLParserTRANSLATE, PostgreSQLParserUNISTR, PostgreSQLParserAGE, PostgreSQLParserCLOCK_TIMESTAMP, PostgreSQLParserDATE_BIN, PostgreSQLParserDATE_PART, PostgreSQLParserDATE_TRUNC, PostgreSQLParserISFINITE, PostgreSQLParserJUSTIFY_DAYS, PostgreSQLParserJUSTIFY_HOURS, PostgreSQLParserJUSTIFY_INTERVAL, PostgreSQLParserMAKE_DATE, PostgreSQLParserMAKE_INTERVAL, PostgreSQLParserMAKE_TIME, PostgreSQLParserMAKE_TIMESTAMP, PostgreSQLParserMAKE_TIMESTAMPTZ, PostgreSQLParserNOW, PostgreSQLParserSTATEMENT_TIMESTAMP, PostgreSQLParserTIMEOFDAY, PostgreSQLParserTRANSACTION_TIMESTAMP, PostgreSQLParserTO_TIMESTAMP, PostgreSQLParserTO_CHAR, PostgreSQLParserTO_DATE, PostgreSQLParserTO_NUMBER, PostgreSQLParserIdentifier, PostgreSQLParserQuotedIdentifier, PostgreSQLParserUnicodeQuotedIdentifier, PostgreSQLParserPLSQLVARIABLENAME, PostgreSQLParserPLSQLIDENTIFIER:
		{
			p.SetState(7748)
			p.Qualified_name()
		}

	default:
		p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		goto errorExit
	}
	p.SetState(7752)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}
	_la = p.GetTokenStream().LA(1)

	if ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&2459027080864595968) != 0) || ((int64((_la-92)) & ^0x3f) == 0 && ((int64(1)<<(_la-92))&-113665638399) != 0) || ((int64((_la-156)) & ^0x3f) == 0 && ((int64(1)<<(_la-156))&-1) != 0) || ((int64((_la-220)) & ^0x3f) == 0 && ((int64(1)<<(_la-220))&-9663676417) != 0) || ((int64((_la-284)) & ^0x3f) == 0 && ((int64(1)<<(_la-284))&-1) != 0) || ((int64((_la-348)) & ^0x3f) == 0 && ((int64(1)<<(_la-348))&-1) != 0) || ((int64((_la-412)) & ^0x3f) == 0 && ((int64(1)<<(_la-412))&-1152925902653358081) != 0) || ((int64((_la-476)) & ^0x3f) == 0 && ((int64(1)<<(_la-476))&-8796764110849) != 0) || ((int64((_la-540)) & ^0x3f) == 0 && ((int64(1)<<(_la-540))&-1) != 0) || ((int64((_la-604)) & ^0x3f) == 0 && ((int64(1)<<(_la-604))&432345718846390271) != 0) {
		{
			p.SetState(7751)
			p.Alias_clause()
		}

	}
	{
		p.SetState(7754)
		p.Match(PostgreSQLParserON)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(7755)
		p.A_expr()
	}
	p.SetState(7764)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 396, p.GetParserRuleContext()) {
	case 1:
		{
			p.SetState(7756)
			p.Merge_insert_clause()
		}
		p.SetState(7758)
		p.GetErrorHandler().Sync(p)

		if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 394, p.GetParserRuleContext()) == 1 {
			{
				p.SetState(7757)
				p.Merge_update_clause()
			}

		} else if p.HasError() { // JIM
			goto errorExit
		}

	case 2:
		{
			p.SetState(7760)
			p.Merge_update_clause()
		}
		p.SetState(7762)
		p.GetErrorHandler().Sync(p)

		if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 395, p.GetParserRuleContext()) == 1 {
			{
				p.SetState(7761)
				p.Merge_insert_clause()
			}

		} else if p.HasError() { // JIM
			goto errorExit
		}

	case antlr.ATNInvalidAltNumber:
		goto errorExit
	}
	p.SetState(7767)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}
	_la = p.GetTokenStream().LA(1)

	if _la == PostgreSQLParserWHEN {
		{
			p.SetState(7766)
			p.Merge_delete_clause()
		}

	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IMerge_insert_clauseContext is an interface to support dynamic dispatch.
type IMerge_insert_clauseContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	WHEN() antlr.TerminalNode
	NOT() antlr.TerminalNode
	MATCHED() antlr.TerminalNode
	INSERT() antlr.TerminalNode
	Values_clause() IValues_clauseContext
	AND() antlr.TerminalNode
	A_expr() IA_exprContext
	THEN() antlr.TerminalNode
	OPEN_PAREN() antlr.TerminalNode
	Insert_column_list() IInsert_column_listContext
	CLOSE_PAREN() antlr.TerminalNode

	// IsMerge_insert_clauseContext differentiates from other interfaces.
	IsMerge_insert_clauseContext()
}

type Merge_insert_clauseContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyMerge_insert_clauseContext() *Merge_insert_clauseContext {
	var p = new(Merge_insert_clauseContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_merge_insert_clause
	return p
}

func InitEmptyMerge_insert_clauseContext(p *Merge_insert_clauseContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_merge_insert_clause
}

func (*Merge_insert_clauseContext) IsMerge_insert_clauseContext() {}

func NewMerge_insert_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Merge_insert_clauseContext {
	var p = new(Merge_insert_clauseContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_merge_insert_clause

	return p
}

func (s *Merge_insert_clauseContext) GetParser() antlr.Parser { return s.parser }

func (s *Merge_insert_clauseContext) WHEN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserWHEN, 0)
}

func (s *Merge_insert_clauseContext) NOT() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserNOT, 0)
}

func (s *Merge_insert_clauseContext) MATCHED() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserMATCHED, 0)
}

func (s *Merge_insert_clauseContext) INSERT() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserINSERT, 0)
}

func (s *Merge_insert_clauseContext) Values_clause() IValues_clauseContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IValues_clauseContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IValues_clauseContext)
}

func (s *Merge_insert_clauseContext) AND() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserAND, 0)
}

func (s *Merge_insert_clauseContext) A_expr() IA_exprContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IA_exprContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IA_exprContext)
}

func (s *Merge_insert_clauseContext) THEN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserTHEN, 0)
}

func (s *Merge_insert_clauseContext) OPEN_PAREN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserOPEN_PAREN, 0)
}

func (s *Merge_insert_clauseContext) Insert_column_list() IInsert_column_listContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IInsert_column_listContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IInsert_column_listContext)
}

func (s *Merge_insert_clauseContext) CLOSE_PAREN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCLOSE_PAREN, 0)
}

func (s *Merge_insert_clauseContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Merge_insert_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Merge_insert_clauseContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterMerge_insert_clause(s)
	}
}

func (s *Merge_insert_clauseContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitMerge_insert_clause(s)
	}
}

func (s *Merge_insert_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitMerge_insert_clause(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Merge_insert_clause() (localctx IMerge_insert_clauseContext) {
	localctx = NewMerge_insert_clauseContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 922, PostgreSQLParserRULE_merge_insert_clause)
	var _la int

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(7769)
		p.Match(PostgreSQLParserWHEN)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(7770)
		p.Match(PostgreSQLParserNOT)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(7771)
		p.Match(PostgreSQLParserMATCHED)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	p.SetState(7774)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}
	_la = p.GetTokenStream().LA(1)

	if _la == PostgreSQLParserAND {
		{
			p.SetState(7772)
			p.Match(PostgreSQLParserAND)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(7773)
			p.A_expr()
		}

	}
	p.SetState(7777)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}
	_la = p.GetTokenStream().LA(1)

	if _la == PostgreSQLParserTHEN {
		{
			p.SetState(7776)
			p.Match(PostgreSQLParserTHEN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	}
	{
		p.SetState(7779)
		p.Match(PostgreSQLParserINSERT)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	p.SetState(7784)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}
	_la = p.GetTokenStream().LA(1)

	if _la == PostgreSQLParserOPEN_PAREN {
		{
			p.SetState(7780)
			p.Match(PostgreSQLParserOPEN_PAREN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(7781)
			p.Insert_column_list()
		}
		{
			p.SetState(7782)
			p.Match(PostgreSQLParserCLOSE_PAREN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	}
	{
		p.SetState(7786)
		p.Values_clause()
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IMerge_update_clauseContext is an interface to support dynamic dispatch.
type IMerge_update_clauseContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	WHEN() antlr.TerminalNode
	MATCHED() antlr.TerminalNode
	UPDATE() antlr.TerminalNode
	SET() antlr.TerminalNode
	Set_clause_list() ISet_clause_listContext
	AND() antlr.TerminalNode
	A_expr() IA_exprContext
	THEN() antlr.TerminalNode

	// IsMerge_update_clauseContext differentiates from other interfaces.
	IsMerge_update_clauseContext()
}

type Merge_update_clauseContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyMerge_update_clauseContext() *Merge_update_clauseContext {
	var p = new(Merge_update_clauseContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_merge_update_clause
	return p
}

func InitEmptyMerge_update_clauseContext(p *Merge_update_clauseContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_merge_update_clause
}

func (*Merge_update_clauseContext) IsMerge_update_clauseContext() {}

func NewMerge_update_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Merge_update_clauseContext {
	var p = new(Merge_update_clauseContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_merge_update_clause

	return p
}

func (s *Merge_update_clauseContext) GetParser() antlr.Parser { return s.parser }

func (s *Merge_update_clauseContext) WHEN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserWHEN, 0)
}

func (s *Merge_update_clauseContext) MATCHED() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserMATCHED, 0)
}

func (s *Merge_update_clauseContext) UPDATE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserUPDATE, 0)
}

func (s *Merge_update_clauseContext) SET() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserSET, 0)
}

func (s *Merge_update_clauseContext) Set_clause_list() ISet_clause_listContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ISet_clause_listContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ISet_clause_listContext)
}

func (s *Merge_update_clauseContext) AND() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserAND, 0)
}

func (s *Merge_update_clauseContext) A_expr() IA_exprContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IA_exprContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IA_exprContext)
}

func (s *Merge_update_clauseContext) THEN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserTHEN, 0)
}

func (s *Merge_update_clauseContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Merge_update_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Merge_update_clauseContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterMerge_update_clause(s)
	}
}

func (s *Merge_update_clauseContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitMerge_update_clause(s)
	}
}

func (s *Merge_update_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitMerge_update_clause(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Merge_update_clause() (localctx IMerge_update_clauseContext) {
	localctx = NewMerge_update_clauseContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 924, PostgreSQLParserRULE_merge_update_clause)
	var _la int

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(7788)
		p.Match(PostgreSQLParserWHEN)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(7789)
		p.Match(PostgreSQLParserMATCHED)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	p.SetState(7792)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}
	_la = p.GetTokenStream().LA(1)

	if _la == PostgreSQLParserAND {
		{
			p.SetState(7790)
			p.Match(PostgreSQLParserAND)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(7791)
			p.A_expr()
		}

	}
	p.SetState(7795)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}
	_la = p.GetTokenStream().LA(1)

	if _la == PostgreSQLParserTHEN {
		{
			p.SetState(7794)
			p.Match(PostgreSQLParserTHEN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	}
	{
		p.SetState(7797)
		p.Match(PostgreSQLParserUPDATE)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(7798)
		p.Match(PostgreSQLParserSET)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(7799)
		p.Set_clause_list()
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IMerge_delete_clauseContext is an interface to support dynamic dispatch.
type IMerge_delete_clauseContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	WHEN() antlr.TerminalNode
	MATCHED() antlr.TerminalNode
	DELETE_P() antlr.TerminalNode
	THEN() antlr.TerminalNode

	// IsMerge_delete_clauseContext differentiates from other interfaces.
	IsMerge_delete_clauseContext()
}

type Merge_delete_clauseContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyMerge_delete_clauseContext() *Merge_delete_clauseContext {
	var p = new(Merge_delete_clauseContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_merge_delete_clause
	return p
}

func InitEmptyMerge_delete_clauseContext(p *Merge_delete_clauseContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_merge_delete_clause
}

func (*Merge_delete_clauseContext) IsMerge_delete_clauseContext() {}

func NewMerge_delete_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Merge_delete_clauseContext {
	var p = new(Merge_delete_clauseContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_merge_delete_clause

	return p
}

func (s *Merge_delete_clauseContext) GetParser() antlr.Parser { return s.parser }

func (s *Merge_delete_clauseContext) WHEN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserWHEN, 0)
}

func (s *Merge_delete_clauseContext) MATCHED() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserMATCHED, 0)
}

func (s *Merge_delete_clauseContext) DELETE_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserDELETE_P, 0)
}

func (s *Merge_delete_clauseContext) THEN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserTHEN, 0)
}

func (s *Merge_delete_clauseContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Merge_delete_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Merge_delete_clauseContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterMerge_delete_clause(s)
	}
}

func (s *Merge_delete_clauseContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitMerge_delete_clause(s)
	}
}

func (s *Merge_delete_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitMerge_delete_clause(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Merge_delete_clause() (localctx IMerge_delete_clauseContext) {
	localctx = NewMerge_delete_clauseContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 926, PostgreSQLParserRULE_merge_delete_clause)
	var _la int

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(7801)
		p.Match(PostgreSQLParserWHEN)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(7802)
		p.Match(PostgreSQLParserMATCHED)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	p.SetState(7804)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}
	_la = p.GetTokenStream().LA(1)

	if _la == PostgreSQLParserTHEN {
		{
			p.SetState(7803)
			p.Match(PostgreSQLParserTHEN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	}
	{
		p.SetState(7806)
		p.Match(PostgreSQLParserDELETE_P)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IDeletestmtContext is an interface to support dynamic dispatch.
type IDeletestmtContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Opt_with_clause() IOpt_with_clauseContext
	DELETE_P() antlr.TerminalNode
	FROM() antlr.TerminalNode
	Relation_expr_opt_alias() IRelation_expr_opt_aliasContext
	Using_clause() IUsing_clauseContext
	Where_or_current_clause() IWhere_or_current_clauseContext
	Returning_clause() IReturning_clauseContext

	// IsDeletestmtContext differentiates from other interfaces.
	IsDeletestmtContext()
}

type DeletestmtContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyDeletestmtContext() *DeletestmtContext {
	var p = new(DeletestmtContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_deletestmt
	return p
}

func InitEmptyDeletestmtContext(p *DeletestmtContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_deletestmt
}

func (*DeletestmtContext) IsDeletestmtContext() {}

func NewDeletestmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DeletestmtContext {
	var p = new(DeletestmtContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_deletestmt

	return p
}

func (s *DeletestmtContext) GetParser() antlr.Parser { return s.parser }

func (s *DeletestmtContext) Opt_with_clause() IOpt_with_clauseContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOpt_with_clauseContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOpt_with_clauseContext)
}

func (s *DeletestmtContext) DELETE_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserDELETE_P, 0)
}

func (s *DeletestmtContext) FROM() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserFROM, 0)
}

func (s *DeletestmtContext) Relation_expr_opt_alias() IRelation_expr_opt_aliasContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IRelation_expr_opt_aliasContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IRelation_expr_opt_aliasContext)
}

func (s *DeletestmtContext) Using_clause() IUsing_clauseContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IUsing_clauseContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IUsing_clauseContext)
}

func (s *DeletestmtContext) Where_or_current_clause() IWhere_or_current_clauseContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IWhere_or_current_clauseContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IWhere_or_current_clauseContext)
}

func (s *DeletestmtContext) Returning_clause() IReturning_clauseContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IReturning_clauseContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IReturning_clauseContext)
}

func (s *DeletestmtContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *DeletestmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *DeletestmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterDeletestmt(s)
	}
}

func (s *DeletestmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitDeletestmt(s)
	}
}

func (s *DeletestmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitDeletestmt(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Deletestmt() (localctx IDeletestmtContext) {
	localctx = NewDeletestmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 928, PostgreSQLParserRULE_deletestmt)
	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(7808)
		p.Opt_with_clause()
	}
	{
		p.SetState(7809)
		p.Match(PostgreSQLParserDELETE_P)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(7810)
		p.Match(PostgreSQLParserFROM)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(7811)
		p.Relation_expr_opt_alias()
	}
	{
		p.SetState(7812)
		p.Using_clause()
	}
	{
		p.SetState(7813)
		p.Where_or_current_clause()
	}
	{
		p.SetState(7814)
		p.Returning_clause()
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IUsing_clauseContext is an interface to support dynamic dispatch.
type IUsing_clauseContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	USING() antlr.TerminalNode
	From_list() IFrom_listContext

	// IsUsing_clauseContext differentiates from other interfaces.
	IsUsing_clauseContext()
}

type Using_clauseContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyUsing_clauseContext() *Using_clauseContext {
	var p = new(Using_clauseContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_using_clause
	return p
}

func InitEmptyUsing_clauseContext(p *Using_clauseContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_using_clause
}

func (*Using_clauseContext) IsUsing_clauseContext() {}

func NewUsing_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Using_clauseContext {
	var p = new(Using_clauseContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_using_clause

	return p
}

func (s *Using_clauseContext) GetParser() antlr.Parser { return s.parser }

func (s *Using_clauseContext) USING() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserUSING, 0)
}

func (s *Using_clauseContext) From_list() IFrom_listContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IFrom_listContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IFrom_listContext)
}

func (s *Using_clauseContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Using_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Using_clauseContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterUsing_clause(s)
	}
}

func (s *Using_clauseContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitUsing_clause(s)
	}
}

func (s *Using_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitUsing_clause(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Using_clause() (localctx IUsing_clauseContext) {
	localctx = NewUsing_clauseContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 930, PostgreSQLParserRULE_using_clause)
	p.SetState(7819)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetTokenStream().LA(1) {
	case PostgreSQLParserUSING:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(7816)
			p.Match(PostgreSQLParserUSING)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(7817)
			p.From_list()
		}

	case PostgreSQLParserEOF, PostgreSQLParserOPEN_PAREN, PostgreSQLParserCLOSE_PAREN, PostgreSQLParserSEMI, PostgreSQLParserANALYSE, PostgreSQLParserANALYZE, PostgreSQLParserCREATE, PostgreSQLParserDO, PostgreSQLParserFETCH, PostgreSQLParserGRANT, PostgreSQLParserINTO, PostgreSQLParserRETURNING, PostgreSQLParserSELECT, PostgreSQLParserTABLE, PostgreSQLParserWHERE, PostgreSQLParserWITH, PostgreSQLParserABORT_P, PostgreSQLParserALTER, PostgreSQLParserBEGIN_P, PostgreSQLParserCHECKPOINT, PostgreSQLParserCLOSE, PostgreSQLParserCLUSTER, PostgreSQLParserCOMMENT, PostgreSQLParserCOMMIT, PostgreSQLParserCOPY, PostgreSQLParserDEALLOCATE, PostgreSQLParserDECLARE, PostgreSQLParserDELETE_P, PostgreSQLParserDISCARD, PostgreSQLParserDROP, PostgreSQLParserEXECUTE, PostgreSQLParserEXPLAIN, PostgreSQLParserINSERT, PostgreSQLParserLISTEN, PostgreSQLParserLOAD, PostgreSQLParserLOCK_P, PostgreSQLParserMERGE, PostgreSQLParserMOVE, PostgreSQLParserNOTIFY, PostgreSQLParserPREPARE, PostgreSQLParserREASSIGN, PostgreSQLParserREFRESH, PostgreSQLParserREINDEX, PostgreSQLParserRELEASE, PostgreSQLParserRESET, PostgreSQLParserREVOKE, PostgreSQLParserROLLBACK, PostgreSQLParserSAVEPOINT, PostgreSQLParserSECURITY, PostgreSQLParserSET, PostgreSQLParserSHOW, PostgreSQLParserSTART, PostgreSQLParserTRUNCATE, PostgreSQLParserUNLISTEN, PostgreSQLParserUPDATE, PostgreSQLParserVACUUM, PostgreSQLParserVALUES, PostgreSQLParserCALL, PostgreSQLParserIMPORT_P, PostgreSQLParserEND_P, PostgreSQLParserLOOP, PostgreSQLParserMetaCommand:
		p.EnterOuterAlt(localctx, 2)

	default:
		p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// ILockstmtContext is an interface to support dynamic dispatch.
type ILockstmtContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	LOCK_P() antlr.TerminalNode
	Opt_table() IOpt_tableContext
	Relation_expr_list() IRelation_expr_listContext
	Opt_lock() IOpt_lockContext
	Opt_nowait() IOpt_nowaitContext

	// IsLockstmtContext differentiates from other interfaces.
	IsLockstmtContext()
}

type LockstmtContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyLockstmtContext() *LockstmtContext {
	var p = new(LockstmtContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_lockstmt
	return p
}

func InitEmptyLockstmtContext(p *LockstmtContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_lockstmt
}

func (*LockstmtContext) IsLockstmtContext() {}

func NewLockstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *LockstmtContext {
	var p = new(LockstmtContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_lockstmt

	return p
}

func (s *LockstmtContext) GetParser() antlr.Parser { return s.parser }

func (s *LockstmtContext) LOCK_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserLOCK_P, 0)
}

func (s *LockstmtContext) Opt_table() IOpt_tableContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOpt_tableContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOpt_tableContext)
}

func (s *LockstmtContext) Relation_expr_list() IRelation_expr_listContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IRelation_expr_listContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IRelation_expr_listContext)
}

func (s *LockstmtContext) Opt_lock() IOpt_lockContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOpt_lockContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOpt_lockContext)
}

func (s *LockstmtContext) Opt_nowait() IOpt_nowaitContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOpt_nowaitContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOpt_nowaitContext)
}

func (s *LockstmtContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *LockstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *LockstmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterLockstmt(s)
	}
}

func (s *LockstmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitLockstmt(s)
	}
}

func (s *LockstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitLockstmt(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Lockstmt() (localctx ILockstmtContext) {
	localctx = NewLockstmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 932, PostgreSQLParserRULE_lockstmt)
	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(7821)
		p.Match(PostgreSQLParserLOCK_P)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(7822)
		p.Opt_table()
	}
	{
		p.SetState(7823)
		p.Relation_expr_list()
	}
	{
		p.SetState(7824)
		p.Opt_lock()
	}
	{
		p.SetState(7825)
		p.Opt_nowait()
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IOpt_lockContext is an interface to support dynamic dispatch.
type IOpt_lockContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	IN_P() antlr.TerminalNode
	Lock_type() ILock_typeContext
	MODE() antlr.TerminalNode

	// IsOpt_lockContext differentiates from other interfaces.
	IsOpt_lockContext()
}

type Opt_lockContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyOpt_lockContext() *Opt_lockContext {
	var p = new(Opt_lockContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opt_lock
	return p
}

func InitEmptyOpt_lockContext(p *Opt_lockContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opt_lock
}

func (*Opt_lockContext) IsOpt_lockContext() {}

func NewOpt_lockContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_lockContext {
	var p = new(Opt_lockContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_opt_lock

	return p
}

func (s *Opt_lockContext) GetParser() antlr.Parser { return s.parser }

func (s *Opt_lockContext) IN_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserIN_P, 0)
}

func (s *Opt_lockContext) Lock_type() ILock_typeContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ILock_typeContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ILock_typeContext)
}

func (s *Opt_lockContext) MODE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserMODE, 0)
}

func (s *Opt_lockContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Opt_lockContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Opt_lockContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterOpt_lock(s)
	}
}

func (s *Opt_lockContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitOpt_lock(s)
	}
}

func (s *Opt_lockContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitOpt_lock(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Opt_lock() (localctx IOpt_lockContext) {
	localctx = NewOpt_lockContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 934, PostgreSQLParserRULE_opt_lock)
	p.SetState(7832)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetTokenStream().LA(1) {
	case PostgreSQLParserIN_P:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(7827)
			p.Match(PostgreSQLParserIN_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(7828)
			p.Lock_type()
		}
		{
			p.SetState(7829)
			p.Match(PostgreSQLParserMODE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case PostgreSQLParserEOF, PostgreSQLParserOPEN_PAREN, PostgreSQLParserSEMI, PostgreSQLParserANALYSE, PostgreSQLParserANALYZE, PostgreSQLParserCREATE, PostgreSQLParserDO, PostgreSQLParserFETCH, PostgreSQLParserGRANT, PostgreSQLParserINTO, PostgreSQLParserSELECT, PostgreSQLParserTABLE, PostgreSQLParserWITH, PostgreSQLParserABORT_P, PostgreSQLParserALTER, PostgreSQLParserBEGIN_P, PostgreSQLParserCHECKPOINT, PostgreSQLParserCLOSE, PostgreSQLParserCLUSTER, PostgreSQLParserCOMMENT, PostgreSQLParserCOMMIT, PostgreSQLParserCOPY, PostgreSQLParserDEALLOCATE, PostgreSQLParserDECLARE, PostgreSQLParserDELETE_P, PostgreSQLParserDISCARD, PostgreSQLParserDROP, PostgreSQLParserEXECUTE, PostgreSQLParserEXPLAIN, PostgreSQLParserINSERT, PostgreSQLParserLISTEN, PostgreSQLParserLOAD, PostgreSQLParserLOCK_P, PostgreSQLParserMERGE, PostgreSQLParserMOVE, PostgreSQLParserNOTIFY, PostgreSQLParserNOWAIT, PostgreSQLParserPREPARE, PostgreSQLParserREASSIGN, PostgreSQLParserREFRESH, PostgreSQLParserREINDEX, PostgreSQLParserRELEASE, PostgreSQLParserRESET, PostgreSQLParserREVOKE, PostgreSQLParserROLLBACK, PostgreSQLParserSAVEPOINT, PostgreSQLParserSECURITY, PostgreSQLParserSET, PostgreSQLParserSHOW, PostgreSQLParserSTART, PostgreSQLParserTRUNCATE, PostgreSQLParserUNLISTEN, PostgreSQLParserUPDATE, PostgreSQLParserVACUUM, PostgreSQLParserVALUES, PostgreSQLParserCALL, PostgreSQLParserIMPORT_P, PostgreSQLParserEND_P, PostgreSQLParserMetaCommand:
		p.EnterOuterAlt(localctx, 2)

	default:
		p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// ILock_typeContext is an interface to support dynamic dispatch.
type ILock_typeContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	ACCESS() antlr.TerminalNode
	SHARE() antlr.TerminalNode
	EXCLUSIVE() antlr.TerminalNode
	ROW() antlr.TerminalNode
	UPDATE() antlr.TerminalNode

	// IsLock_typeContext differentiates from other interfaces.
	IsLock_typeContext()
}

type Lock_typeContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyLock_typeContext() *Lock_typeContext {
	var p = new(Lock_typeContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_lock_type
	return p
}

func InitEmptyLock_typeContext(p *Lock_typeContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_lock_type
}

func (*Lock_typeContext) IsLock_typeContext() {}

func NewLock_typeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Lock_typeContext {
	var p = new(Lock_typeContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_lock_type

	return p
}

func (s *Lock_typeContext) GetParser() antlr.Parser { return s.parser }

func (s *Lock_typeContext) ACCESS() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserACCESS, 0)
}

func (s *Lock_typeContext) SHARE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserSHARE, 0)
}

func (s *Lock_typeContext) EXCLUSIVE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserEXCLUSIVE, 0)
}

func (s *Lock_typeContext) ROW() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserROW, 0)
}

func (s *Lock_typeContext) UPDATE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserUPDATE, 0)
}

func (s *Lock_typeContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Lock_typeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Lock_typeContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterLock_type(s)
	}
}

func (s *Lock_typeContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitLock_type(s)
	}
}

func (s *Lock_typeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitLock_type(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Lock_type() (localctx ILock_typeContext) {
	localctx = NewLock_typeContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 936, PostgreSQLParserRULE_lock_type)
	var _la int

	p.SetState(7846)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetTokenStream().LA(1) {
	case PostgreSQLParserACCESS:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(7834)
			p.Match(PostgreSQLParserACCESS)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(7835)
			_la = p.GetTokenStream().LA(1)

			if !(_la == PostgreSQLParserEXCLUSIVE || _la == PostgreSQLParserSHARE) {
				p.GetErrorHandler().RecoverInline(p)
			} else {
				p.GetErrorHandler().ReportMatch(p)
				p.Consume()
			}
		}

	case PostgreSQLParserROW:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(7836)
			p.Match(PostgreSQLParserROW)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(7837)
			_la = p.GetTokenStream().LA(1)

			if !(_la == PostgreSQLParserEXCLUSIVE || _la == PostgreSQLParserSHARE) {
				p.GetErrorHandler().RecoverInline(p)
			} else {
				p.GetErrorHandler().ReportMatch(p)
				p.Consume()
			}
		}

	case PostgreSQLParserSHARE:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(7838)
			p.Match(PostgreSQLParserSHARE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		p.SetState(7843)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}
		switch p.GetTokenStream().LA(1) {
		case PostgreSQLParserUPDATE:
			{
				p.SetState(7839)
				p.Match(PostgreSQLParserUPDATE)
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}
			{
				p.SetState(7840)
				p.Match(PostgreSQLParserEXCLUSIVE)
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}

		case PostgreSQLParserROW:
			{
				p.SetState(7841)
				p.Match(PostgreSQLParserROW)
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}
			{
				p.SetState(7842)
				p.Match(PostgreSQLParserEXCLUSIVE)
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}

		case PostgreSQLParserMODE:

		default:
		}

	case PostgreSQLParserEXCLUSIVE:
		p.EnterOuterAlt(localctx, 4)
		{
			p.SetState(7845)
			p.Match(PostgreSQLParserEXCLUSIVE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	default:
		p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IOpt_nowaitContext is an interface to support dynamic dispatch.
type IOpt_nowaitContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	NOWAIT() antlr.TerminalNode

	// IsOpt_nowaitContext differentiates from other interfaces.
	IsOpt_nowaitContext()
}

type Opt_nowaitContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyOpt_nowaitContext() *Opt_nowaitContext {
	var p = new(Opt_nowaitContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opt_nowait
	return p
}

func InitEmptyOpt_nowaitContext(p *Opt_nowaitContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opt_nowait
}

func (*Opt_nowaitContext) IsOpt_nowaitContext() {}

func NewOpt_nowaitContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_nowaitContext {
	var p = new(Opt_nowaitContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_opt_nowait

	return p
}

func (s *Opt_nowaitContext) GetParser() antlr.Parser { return s.parser }

func (s *Opt_nowaitContext) NOWAIT() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserNOWAIT, 0)
}

func (s *Opt_nowaitContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Opt_nowaitContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Opt_nowaitContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterOpt_nowait(s)
	}
}

func (s *Opt_nowaitContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitOpt_nowait(s)
	}
}

func (s *Opt_nowaitContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitOpt_nowait(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Opt_nowait() (localctx IOpt_nowaitContext) {
	localctx = NewOpt_nowaitContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 938, PostgreSQLParserRULE_opt_nowait)
	p.SetState(7850)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetTokenStream().LA(1) {
	case PostgreSQLParserNOWAIT:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(7848)
			p.Match(PostgreSQLParserNOWAIT)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case PostgreSQLParserEOF, PostgreSQLParserOPEN_PAREN, PostgreSQLParserSEMI, PostgreSQLParserANALYSE, PostgreSQLParserANALYZE, PostgreSQLParserCREATE, PostgreSQLParserDO, PostgreSQLParserFETCH, PostgreSQLParserGRANT, PostgreSQLParserINTO, PostgreSQLParserSELECT, PostgreSQLParserTABLE, PostgreSQLParserWITH, PostgreSQLParserABORT_P, PostgreSQLParserALTER, PostgreSQLParserBEGIN_P, PostgreSQLParserCHECKPOINT, PostgreSQLParserCLOSE, PostgreSQLParserCLUSTER, PostgreSQLParserCOMMENT, PostgreSQLParserCOMMIT, PostgreSQLParserCOPY, PostgreSQLParserDEALLOCATE, PostgreSQLParserDECLARE, PostgreSQLParserDELETE_P, PostgreSQLParserDISCARD, PostgreSQLParserDROP, PostgreSQLParserEXECUTE, PostgreSQLParserEXPLAIN, PostgreSQLParserINSERT, PostgreSQLParserLISTEN, PostgreSQLParserLOAD, PostgreSQLParserLOCK_P, PostgreSQLParserMERGE, PostgreSQLParserMOVE, PostgreSQLParserNOTIFY, PostgreSQLParserPREPARE, PostgreSQLParserREASSIGN, PostgreSQLParserREFRESH, PostgreSQLParserREINDEX, PostgreSQLParserRELEASE, PostgreSQLParserRESET, PostgreSQLParserREVOKE, PostgreSQLParserROLLBACK, PostgreSQLParserSAVEPOINT, PostgreSQLParserSECURITY, PostgreSQLParserSET, PostgreSQLParserSHOW, PostgreSQLParserSTART, PostgreSQLParserTRUNCATE, PostgreSQLParserUNLISTEN, PostgreSQLParserUPDATE, PostgreSQLParserVACUUM, PostgreSQLParserVALUES, PostgreSQLParserCALL, PostgreSQLParserIMPORT_P, PostgreSQLParserEND_P, PostgreSQLParserMetaCommand:
		p.EnterOuterAlt(localctx, 2)

	default:
		p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IOpt_nowait_or_skipContext is an interface to support dynamic dispatch.
type IOpt_nowait_or_skipContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	NOWAIT() antlr.TerminalNode
	SKIP_P() antlr.TerminalNode
	LOCKED() antlr.TerminalNode

	// IsOpt_nowait_or_skipContext differentiates from other interfaces.
	IsOpt_nowait_or_skipContext()
}

type Opt_nowait_or_skipContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyOpt_nowait_or_skipContext() *Opt_nowait_or_skipContext {
	var p = new(Opt_nowait_or_skipContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opt_nowait_or_skip
	return p
}

func InitEmptyOpt_nowait_or_skipContext(p *Opt_nowait_or_skipContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opt_nowait_or_skip
}

func (*Opt_nowait_or_skipContext) IsOpt_nowait_or_skipContext() {}

func NewOpt_nowait_or_skipContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_nowait_or_skipContext {
	var p = new(Opt_nowait_or_skipContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_opt_nowait_or_skip

	return p
}

func (s *Opt_nowait_or_skipContext) GetParser() antlr.Parser { return s.parser }

func (s *Opt_nowait_or_skipContext) NOWAIT() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserNOWAIT, 0)
}

func (s *Opt_nowait_or_skipContext) SKIP_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserSKIP_P, 0)
}

func (s *Opt_nowait_or_skipContext) LOCKED() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserLOCKED, 0)
}

func (s *Opt_nowait_or_skipContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Opt_nowait_or_skipContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Opt_nowait_or_skipContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterOpt_nowait_or_skip(s)
	}
}

func (s *Opt_nowait_or_skipContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitOpt_nowait_or_skip(s)
	}
}

func (s *Opt_nowait_or_skipContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitOpt_nowait_or_skip(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Opt_nowait_or_skip() (localctx IOpt_nowait_or_skipContext) {
	localctx = NewOpt_nowait_or_skipContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 940, PostgreSQLParserRULE_opt_nowait_or_skip)
	p.SetState(7856)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetTokenStream().LA(1) {
	case PostgreSQLParserNOWAIT:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(7852)
			p.Match(PostgreSQLParserNOWAIT)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case PostgreSQLParserSKIP_P:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(7853)
			p.Match(PostgreSQLParserSKIP_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(7854)
			p.Match(PostgreSQLParserLOCKED)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case PostgreSQLParserEOF, PostgreSQLParserOPEN_PAREN, PostgreSQLParserCLOSE_PAREN, PostgreSQLParserSEMI, PostgreSQLParserANALYSE, PostgreSQLParserANALYZE, PostgreSQLParserCREATE, PostgreSQLParserDO, PostgreSQLParserFETCH, PostgreSQLParserFOR, PostgreSQLParserGRANT, PostgreSQLParserINTO, PostgreSQLParserLIMIT, PostgreSQLParserOFFSET, PostgreSQLParserON, PostgreSQLParserRETURNING, PostgreSQLParserSELECT, PostgreSQLParserTABLE, PostgreSQLParserWITH, PostgreSQLParserABORT_P, PostgreSQLParserALTER, PostgreSQLParserBEGIN_P, PostgreSQLParserCHECKPOINT, PostgreSQLParserCLOSE, PostgreSQLParserCLUSTER, PostgreSQLParserCOMMENT, PostgreSQLParserCOMMIT, PostgreSQLParserCOPY, PostgreSQLParserDEALLOCATE, PostgreSQLParserDECLARE, PostgreSQLParserDELETE_P, PostgreSQLParserDISCARD, PostgreSQLParserDROP, PostgreSQLParserEXECUTE, PostgreSQLParserEXPLAIN, PostgreSQLParserINSERT, PostgreSQLParserLISTEN, PostgreSQLParserLOAD, PostgreSQLParserLOCK_P, PostgreSQLParserMERGE, PostgreSQLParserMOVE, PostgreSQLParserNOTIFY, PostgreSQLParserPREPARE, PostgreSQLParserREASSIGN, PostgreSQLParserREFRESH, PostgreSQLParserREINDEX, PostgreSQLParserRELEASE, PostgreSQLParserRESET, PostgreSQLParserREVOKE, PostgreSQLParserROLLBACK, PostgreSQLParserSAVEPOINT, PostgreSQLParserSECURITY, PostgreSQLParserSET, PostgreSQLParserSHOW, PostgreSQLParserSTART, PostgreSQLParserTRUNCATE, PostgreSQLParserUNLISTEN, PostgreSQLParserUPDATE, PostgreSQLParserVACUUM, PostgreSQLParserVALUES, PostgreSQLParserCALL, PostgreSQLParserIMPORT_P, PostgreSQLParserEND_P, PostgreSQLParserLOOP, PostgreSQLParserMetaCommand:
		p.EnterOuterAlt(localctx, 3)

	default:
		p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IUpdatestmtContext is an interface to support dynamic dispatch.
type IUpdatestmtContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Opt_with_clause() IOpt_with_clauseContext
	UPDATE() antlr.TerminalNode
	Relation_expr_opt_alias() IRelation_expr_opt_aliasContext
	SET() antlr.TerminalNode
	Set_clause_list() ISet_clause_listContext
	From_clause() IFrom_clauseContext
	Where_or_current_clause() IWhere_or_current_clauseContext
	Returning_clause() IReturning_clauseContext

	// IsUpdatestmtContext differentiates from other interfaces.
	IsUpdatestmtContext()
}

type UpdatestmtContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyUpdatestmtContext() *UpdatestmtContext {
	var p = new(UpdatestmtContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_updatestmt
	return p
}

func InitEmptyUpdatestmtContext(p *UpdatestmtContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_updatestmt
}

func (*UpdatestmtContext) IsUpdatestmtContext() {}

func NewUpdatestmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *UpdatestmtContext {
	var p = new(UpdatestmtContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_updatestmt

	return p
}

func (s *UpdatestmtContext) GetParser() antlr.Parser { return s.parser }

func (s *UpdatestmtContext) Opt_with_clause() IOpt_with_clauseContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOpt_with_clauseContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOpt_with_clauseContext)
}

func (s *UpdatestmtContext) UPDATE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserUPDATE, 0)
}

func (s *UpdatestmtContext) Relation_expr_opt_alias() IRelation_expr_opt_aliasContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IRelation_expr_opt_aliasContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IRelation_expr_opt_aliasContext)
}

func (s *UpdatestmtContext) SET() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserSET, 0)
}

func (s *UpdatestmtContext) Set_clause_list() ISet_clause_listContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ISet_clause_listContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ISet_clause_listContext)
}

func (s *UpdatestmtContext) From_clause() IFrom_clauseContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IFrom_clauseContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IFrom_clauseContext)
}

func (s *UpdatestmtContext) Where_or_current_clause() IWhere_or_current_clauseContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IWhere_or_current_clauseContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IWhere_or_current_clauseContext)
}

func (s *UpdatestmtContext) Returning_clause() IReturning_clauseContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IReturning_clauseContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IReturning_clauseContext)
}

func (s *UpdatestmtContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *UpdatestmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *UpdatestmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterUpdatestmt(s)
	}
}

func (s *UpdatestmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitUpdatestmt(s)
	}
}

func (s *UpdatestmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitUpdatestmt(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Updatestmt() (localctx IUpdatestmtContext) {
	localctx = NewUpdatestmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 942, PostgreSQLParserRULE_updatestmt)
	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(7858)
		p.Opt_with_clause()
	}
	{
		p.SetState(7859)
		p.Match(PostgreSQLParserUPDATE)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(7860)
		p.Relation_expr_opt_alias()
	}
	{
		p.SetState(7861)
		p.Match(PostgreSQLParserSET)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(7862)
		p.Set_clause_list()
	}
	{
		p.SetState(7863)
		p.From_clause()
	}
	{
		p.SetState(7864)
		p.Where_or_current_clause()
	}
	{
		p.SetState(7865)
		p.Returning_clause()
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// ISet_clause_listContext is an interface to support dynamic dispatch.
type ISet_clause_listContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	AllSet_clause() []ISet_clauseContext
	Set_clause(i int) ISet_clauseContext
	AllCOMMA() []antlr.TerminalNode
	COMMA(i int) antlr.TerminalNode

	// IsSet_clause_listContext differentiates from other interfaces.
	IsSet_clause_listContext()
}

type Set_clause_listContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptySet_clause_listContext() *Set_clause_listContext {
	var p = new(Set_clause_listContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_set_clause_list
	return p
}

func InitEmptySet_clause_listContext(p *Set_clause_listContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_set_clause_list
}

func (*Set_clause_listContext) IsSet_clause_listContext() {}

func NewSet_clause_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Set_clause_listContext {
	var p = new(Set_clause_listContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_set_clause_list

	return p
}

func (s *Set_clause_listContext) GetParser() antlr.Parser { return s.parser }

func (s *Set_clause_listContext) AllSet_clause() []ISet_clauseContext {
	children := s.GetChildren()
	len := 0
	for _, ctx := range children {
		if _, ok := ctx.(ISet_clauseContext); ok {
			len++
		}
	}

	tst := make([]ISet_clauseContext, len)
	i := 0
	for _, ctx := range children {
		if t, ok := ctx.(ISet_clauseContext); ok {
			tst[i] = t.(ISet_clauseContext)
			i++
		}
	}

	return tst
}

func (s *Set_clause_listContext) Set_clause(i int) ISet_clauseContext {
	var t antlr.RuleContext
	j := 0
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ISet_clauseContext); ok {
			if j == i {
				t = ctx.(antlr.RuleContext)
				break
			}
			j++
		}
	}

	if t == nil {
		return nil
	}

	return t.(ISet_clauseContext)
}

func (s *Set_clause_listContext) AllCOMMA() []antlr.TerminalNode {
	return s.GetTokens(PostgreSQLParserCOMMA)
}

func (s *Set_clause_listContext) COMMA(i int) antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCOMMA, i)
}

func (s *Set_clause_listContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Set_clause_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Set_clause_listContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterSet_clause_list(s)
	}
}

func (s *Set_clause_listContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitSet_clause_list(s)
	}
}

func (s *Set_clause_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitSet_clause_list(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Set_clause_list() (localctx ISet_clause_listContext) {
	localctx = NewSet_clause_listContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 944, PostgreSQLParserRULE_set_clause_list)
	var _la int

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(7867)
		p.Set_clause()
	}
	p.SetState(7872)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}
	_la = p.GetTokenStream().LA(1)

	for _la == PostgreSQLParserCOMMA {
		{
			p.SetState(7868)
			p.Match(PostgreSQLParserCOMMA)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(7869)
			p.Set_clause()
		}

		p.SetState(7874)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}
		_la = p.GetTokenStream().LA(1)
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// ISet_clauseContext is an interface to support dynamic dispatch.
type ISet_clauseContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Set_target() ISet_targetContext
	EQUAL() antlr.TerminalNode
	A_expr() IA_exprContext
	OPEN_PAREN() antlr.TerminalNode
	Set_target_list() ISet_target_listContext
	CLOSE_PAREN() antlr.TerminalNode

	// IsSet_clauseContext differentiates from other interfaces.
	IsSet_clauseContext()
}

type Set_clauseContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptySet_clauseContext() *Set_clauseContext {
	var p = new(Set_clauseContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_set_clause
	return p
}

func InitEmptySet_clauseContext(p *Set_clauseContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_set_clause
}

func (*Set_clauseContext) IsSet_clauseContext() {}

func NewSet_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Set_clauseContext {
	var p = new(Set_clauseContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_set_clause

	return p
}

func (s *Set_clauseContext) GetParser() antlr.Parser { return s.parser }

func (s *Set_clauseContext) Set_target() ISet_targetContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ISet_targetContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ISet_targetContext)
}

func (s *Set_clauseContext) EQUAL() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserEQUAL, 0)
}

func (s *Set_clauseContext) A_expr() IA_exprContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IA_exprContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IA_exprContext)
}

func (s *Set_clauseContext) OPEN_PAREN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserOPEN_PAREN, 0)
}

func (s *Set_clauseContext) Set_target_list() ISet_target_listContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ISet_target_listContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ISet_target_listContext)
}

func (s *Set_clauseContext) CLOSE_PAREN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCLOSE_PAREN, 0)
}

func (s *Set_clauseContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Set_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Set_clauseContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterSet_clause(s)
	}
}

func (s *Set_clauseContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitSet_clause(s)
	}
}

func (s *Set_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitSet_clause(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Set_clause() (localctx ISet_clauseContext) {
	localctx = NewSet_clauseContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 946, PostgreSQLParserRULE_set_clause)
	p.SetState(7885)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetTokenStream().LA(1) {
	case PostgreSQLParserAND, PostgreSQLParserARRAY, PostgreSQLParserCOLLATE, PostgreSQLParserCOLUMN, PostgreSQLParserCONSTRAINT, PostgreSQLParserDEFAULT, PostgreSQLParserDO, PostgreSQLParserFETCH, PostgreSQLParserTABLE, PostgreSQLParserIS, PostgreSQLParserLEFT, PostgreSQLParserOUTER_P, PostgreSQLParserOVER, PostgreSQLParserRIGHT, PostgreSQLParserABORT_P, PostgreSQLParserABSOLUTE_P, PostgreSQLParserACCESS, PostgreSQLParserACTION, PostgreSQLParserADD_P, PostgreSQLParserADMIN, PostgreSQLParserAFTER, PostgreSQLParserAGGREGATE, PostgreSQLParserALSO, PostgreSQLParserALTER, PostgreSQLParserALWAYS, PostgreSQLParserASSERTION, PostgreSQLParserASSIGNMENT, PostgreSQLParserAT, PostgreSQLParserATTRIBUTE, PostgreSQLParserBACKWARD, PostgreSQLParserBEFORE, PostgreSQLParserBEGIN_P, PostgreSQLParserBY, PostgreSQLParserCACHE, PostgreSQLParserCALLED, PostgreSQLParserCASCADE, PostgreSQLParserCASCADED, PostgreSQLParserCATALOG, PostgreSQLParserCHAIN, PostgreSQLParserCHARACTERISTICS, PostgreSQLParserCHECKPOINT, PostgreSQLParserCLASS, PostgreSQLParserCLOSE, PostgreSQLParserCLUSTER, PostgreSQLParserCOMMENT, PostgreSQLParserCOMMENTS, PostgreSQLParserCOMMIT, PostgreSQLParserCOMMITTED, PostgreSQLParserCONFIGURATION, PostgreSQLParserCONNECTION, PostgreSQLParserCONSTRAINTS, PostgreSQLParserCONTENT_P, PostgreSQLParserCONTINUE_P, PostgreSQLParserCONVERSION_P, PostgreSQLParserCOPY, PostgreSQLParserCOST, PostgreSQLParserCSV, PostgreSQLParserCURSOR, PostgreSQLParserCYCLE, PostgreSQLParserDATA_P, PostgreSQLParserDATABASE, PostgreSQLParserDAY_P, PostgreSQLParserDEALLOCATE, PostgreSQLParserDECLARE, PostgreSQLParserDEFAULTS, PostgreSQLParserDEFERRED, PostgreSQLParserDEFINER, PostgreSQLParserDELETE_P, PostgreSQLParserDELIMITER, PostgreSQLParserDELIMITERS, PostgreSQLParserDICTIONARY, PostgreSQLParserDISABLE_P, PostgreSQLParserDISCARD, PostgreSQLParserDOCUMENT_P, PostgreSQLParserDOMAIN_P, PostgreSQLParserDOUBLE_P, PostgreSQLParserDROP, PostgreSQLParserEACH, PostgreSQLParserENABLE_P, PostgreSQLParserENCODING, PostgreSQLParserENCRYPTED, PostgreSQLParserENUM_P, PostgreSQLParserESCAPE, PostgreSQLParserEVENT, PostgreSQLParserEXCLUDE, PostgreSQLParserEXCLUDING, PostgreSQLParserEXCLUSIVE, PostgreSQLParserEXECUTE, PostgreSQLParserEXPLAIN, PostgreSQLParserEXTENSION, PostgreSQLParserEXTERNAL, PostgreSQLParserFAMILY, PostgreSQLParserFIRST_P, PostgreSQLParserFOLLOWING, PostgreSQLParserFORCE, PostgreSQLParserFORWARD, PostgreSQLParserFUNCTION, PostgreSQLParserFUNCTIONS, PostgreSQLParserGLOBAL, PostgreSQLParserGRANTED, PostgreSQLParserHANDLER, PostgreSQLParserHEADER_P, PostgreSQLParserHOLD, PostgreSQLParserHOUR_P, PostgreSQLParserIDENTITY_P, PostgreSQLParserIF_P, PostgreSQLParserIMMEDIATE, PostgreSQLParserIMMUTABLE, PostgreSQLParserIMPLICIT_P, PostgreSQLParserINCLUDING, PostgreSQLParserINCREMENT, PostgreSQLParserINDEX, PostgreSQLParserINDEXES, PostgreSQLParserINHERIT, PostgreSQLParserINHERITS, PostgreSQLParserINLINE_P, PostgreSQLParserINSENSITIVE, PostgreSQLParserINSERT, PostgreSQLParserINSTEAD, PostgreSQLParserINVOKER, PostgreSQLParserISOLATION, PostgreSQLParserKEY, PostgreSQLParserLABEL, PostgreSQLParserLANGUAGE, PostgreSQLParserLARGE_P, PostgreSQLParserLAST_P, PostgreSQLParserLEAKPROOF, PostgreSQLParserLEVEL, PostgreSQLParserLISTEN, PostgreSQLParserLOAD, PostgreSQLParserLOCAL, PostgreSQLParserLOCATION, PostgreSQLParserLOCK_P, PostgreSQLParserMAPPING, PostgreSQLParserMATCH, PostgreSQLParserMATERIALIZED, PostgreSQLParserMAXVALUE, PostgreSQLParserMINUTE_P, PostgreSQLParserMINVALUE, PostgreSQLParserMODE, PostgreSQLParserMONTH_P, PostgreSQLParserMOVE, PostgreSQLParserNAME_P, PostgreSQLParserNAMES, PostgreSQLParserNEXT, PostgreSQLParserNO, PostgreSQLParserNOTHING, PostgreSQLParserNOTIFY, PostgreSQLParserNOWAIT, PostgreSQLParserNULLS_P, PostgreSQLParserOBJECT_P, PostgreSQLParserOF, PostgreSQLParserOFF, PostgreSQLParserOIDS, PostgreSQLParserOPERATOR, PostgreSQLParserOPTION, PostgreSQLParserOPTIONS, PostgreSQLParserOWNED, PostgreSQLParserOWNER, PostgreSQLParserPARSER, PostgreSQLParserPARTIAL, PostgreSQLParserPARTITION, PostgreSQLParserPASSING, PostgreSQLParserPASSWORD, PostgreSQLParserPLANS, PostgreSQLParserPRECEDING, PostgreSQLParserPREPARE, PostgreSQLParserPREPARED, PostgreSQLParserPRESERVE, PostgreSQLParserPRIOR, PostgreSQLParserPRIVILEGES, PostgreSQLParserPROCEDURAL, PostgreSQLParserPROCEDURE, PostgreSQLParserPROGRAM, PostgreSQLParserQUOTE, PostgreSQLParserRANGE, PostgreSQLParserREAD, PostgreSQLParserREASSIGN, PostgreSQLParserRECHECK, PostgreSQLParserRECURSIVE, PostgreSQLParserREF, PostgreSQLParserREFRESH, PostgreSQLParserREINDEX, PostgreSQLParserRELATIVE_P, PostgreSQLParserRELEASE, PostgreSQLParserRENAME, PostgreSQLParserREPEATABLE, PostgreSQLParserREPLACE, PostgreSQLParserREPLICA, PostgreSQLParserRESET, PostgreSQLParserRESTART, PostgreSQLParserRESTRICT, PostgreSQLParserRETURNS, PostgreSQLParserREVOKE, PostgreSQLParserROLE, PostgreSQLParserROLLBACK, PostgreSQLParserROWS, PostgreSQLParserRULE, PostgreSQLParserSAVEPOINT, PostgreSQLParserSCHEMA, PostgreSQLParserSCROLL, PostgreSQLParserSEARCH, PostgreSQLParserSECOND_P, PostgreSQLParserSECURITY, PostgreSQLParserSEQUENCE, PostgreSQLParserSEQUENCES, PostgreSQLParserSERIALIZABLE, PostgreSQLParserSERVER, PostgreSQLParserSESSION, PostgreSQLParserSET, PostgreSQLParserSHARE, PostgreSQLParserSHOW, PostgreSQLParserSIMPLE, PostgreSQLParserSNAPSHOT, PostgreSQLParserSTABLE, PostgreSQLParserSTANDALONE_P, PostgreSQLParserSTART, PostgreSQLParserSTATEMENT, PostgreSQLParserSTATISTICS, PostgreSQLParserSTDIN, PostgreSQLParserSTDOUT, PostgreSQLParserSTORAGE, PostgreSQLParserSTRICT_P, PostgreSQLParserSTRIP_P, PostgreSQLParserSYSID, PostgreSQLParserSYSTEM_P, PostgreSQLParserTABLES, PostgreSQLParserTABLESPACE, PostgreSQLParserTEMP, PostgreSQLParserTEMPLATE, PostgreSQLParserTEMPORARY, PostgreSQLParserTEXT_P, PostgreSQLParserTRANSACTION, PostgreSQLParserTRIGGER, PostgreSQLParserTRUNCATE, PostgreSQLParserTRUSTED, PostgreSQLParserTYPE_P, PostgreSQLParserTYPES_P, PostgreSQLParserUNBOUNDED, PostgreSQLParserUNCOMMITTED, PostgreSQLParserUNENCRYPTED, PostgreSQLParserUNKNOWN, PostgreSQLParserUNLISTEN, PostgreSQLParserUNLOGGED, PostgreSQLParserUNTIL, PostgreSQLParserUPDATE, PostgreSQLParserVACUUM, PostgreSQLParserVALID, PostgreSQLParserVALIDATE, PostgreSQLParserVALIDATOR, PostgreSQLParserVARYING, PostgreSQLParserVERSION_P, PostgreSQLParserVIEW, PostgreSQLParserVOLATILE, PostgreSQLParserWHITESPACE_P, PostgreSQLParserWITHOUT, PostgreSQLParserWORK, PostgreSQLParserWRAPPER, PostgreSQLParserWRITE, PostgreSQLParserXML_P, PostgreSQLParserYEAR_P, PostgreSQLParserYES_P, PostgreSQLParserZONE, PostgreSQLParserBETWEEN, PostgreSQLParserBIGINT, PostgreSQLParserBIT, PostgreSQLParserBOOLEAN_P, PostgreSQLParserCHAR_P, PostgreSQLParserCHARACTER, PostgreSQLParserCOALESCE, PostgreSQLParserDEC, PostgreSQLParserDECIMAL_P, PostgreSQLParserEXISTS, PostgreSQLParserEXTRACT, PostgreSQLParserFLOAT_P, PostgreSQLParserGREATEST, PostgreSQLParserINOUT, PostgreSQLParserINT_P, PostgreSQLParserINTEGER, PostgreSQLParserINTERVAL, PostgreSQLParserLEAST, PostgreSQLParserNATIONAL, PostgreSQLParserNCHAR, PostgreSQLParserNONE, PostgreSQLParserNULLIF, PostgreSQLParserNUMERIC, PostgreSQLParserOVERLAY, PostgreSQLParserPOSITION, PostgreSQLParserPRECISION, PostgreSQLParserREAL, PostgreSQLParserROW, PostgreSQLParserSETOF, PostgreSQLParserSMALLINT, PostgreSQLParserSUBSTRING, PostgreSQLParserTIME, PostgreSQLParserTIMESTAMP, PostgreSQLParserTREAT, PostgreSQLParserTRIM, PostgreSQLParserVALUES, PostgreSQLParserVARCHAR, PostgreSQLParserXMLATTRIBUTES, PostgreSQLParserXMLCOMMENT, PostgreSQLParserXMLAGG, PostgreSQLParserXML_IS_WELL_FORMED, PostgreSQLParserXML_IS_WELL_FORMED_DOCUMENT, PostgreSQLParserXML_IS_WELL_FORMED_CONTENT, PostgreSQLParserXPATH, PostgreSQLParserXPATH_EXISTS, PostgreSQLParserXMLCONCAT, PostgreSQLParserXMLELEMENT, PostgreSQLParserXMLEXISTS, PostgreSQLParserXMLFOREST, PostgreSQLParserXMLPARSE, PostgreSQLParserXMLPI, PostgreSQLParserXMLROOT, PostgreSQLParserXMLSERIALIZE, PostgreSQLParserCALL, PostgreSQLParserCURRENT_P, PostgreSQLParserATTACH, PostgreSQLParserDETACH, PostgreSQLParserEXPRESSION, PostgreSQLParserGENERATED, PostgreSQLParserLOGGED, PostgreSQLParserSTORED, PostgreSQLParserINCLUDE, PostgreSQLParserROUTINE, PostgreSQLParserTRANSFORM, PostgreSQLParserIMPORT_P, PostgreSQLParserPOLICY, PostgreSQLParserMETHOD, PostgreSQLParserREFERENCING, PostgreSQLParserNEW, PostgreSQLParserOLD, PostgreSQLParserVALUE_P, PostgreSQLParserSUBSCRIPTION, PostgreSQLParserPUBLICATION, PostgreSQLParserOUT_P, PostgreSQLParserROUTINES, PostgreSQLParserSCHEMAS, PostgreSQLParserPROCEDURES, PostgreSQLParserINPUT_P, PostgreSQLParserSUPPORT, PostgreSQLParserPARALLEL, PostgreSQLParserSQL_P, PostgreSQLParserDEPENDS, PostgreSQLParserOVERRIDING, PostgreSQLParserCONFLICT, PostgreSQLParserSKIP_P, PostgreSQLParserLOCKED, PostgreSQLParserTIES, PostgreSQLParserROLLUP, PostgreSQLParserCUBE, PostgreSQLParserGROUPING, PostgreSQLParserSETS, PostgreSQLParserORDINALITY, PostgreSQLParserXMLTABLE, PostgreSQLParserCOLUMNS, PostgreSQLParserXMLNAMESPACES, PostgreSQLParserROWTYPE, PostgreSQLParserNORMALIZED, PostgreSQLParserWITHIN, PostgreSQLParserFILTER, PostgreSQLParserGROUPS, PostgreSQLParserOTHERS, PostgreSQLParserNFC, PostgreSQLParserNFD, PostgreSQLParserNFKC, PostgreSQLParserNFKD, PostgreSQLParserUESCAPE, PostgreSQLParserVIEWS, PostgreSQLParserNORMALIZE, PostgreSQLParserDUMP, PostgreSQLParserPRINT_STRICT_PARAMS, PostgreSQLParserVARIABLE_CONFLICT, PostgreSQLParserERROR, PostgreSQLParserUSE_VARIABLE, PostgreSQLParserUSE_COLUMN, PostgreSQLParserALIAS, PostgreSQLParserCONSTANT, PostgreSQLParserPERFORM, PostgreSQLParserGET, PostgreSQLParserDIAGNOSTICS, PostgreSQLParserSTACKED, PostgreSQLParserELSIF, PostgreSQLParserREVERSE, PostgreSQLParserSLICE, PostgreSQLParserEXIT, PostgreSQLParserRETURN, PostgreSQLParserQUERY, PostgreSQLParserRAISE, PostgreSQLParserSQLSTATE, PostgreSQLParserDEBUG, PostgreSQLParserLOG, PostgreSQLParserINFO, PostgreSQLParserNOTICE, PostgreSQLParserWARNING, PostgreSQLParserEXCEPTION, PostgreSQLParserASSERT, PostgreSQLParserOPEN, PostgreSQLParserABS, PostgreSQLParserCBRT, PostgreSQLParserCEIL, PostgreSQLParserCEILING, PostgreSQLParserDEGREES, PostgreSQLParserDIV, PostgreSQLParserEXP, PostgreSQLParserFACTORIAL, PostgreSQLParserFLOOR, PostgreSQLParserGCD, PostgreSQLParserLCM, PostgreSQLParserLN, PostgreSQLParserLOG10, PostgreSQLParserMIN_SCALE, PostgreSQLParserMOD, PostgreSQLParserPI, PostgreSQLParserPOWER, PostgreSQLParserRADIANS, PostgreSQLParserROUND, PostgreSQLParserSCALE, PostgreSQLParserSIGN, PostgreSQLParserSQRT, PostgreSQLParserTRIM_SCALE, PostgreSQLParserTRUNC, PostgreSQLParserWIDTH_BUCKET, PostgreSQLParserRANDOM, PostgreSQLParserSETSEED, PostgreSQLParserACOS, PostgreSQLParserACOSD, PostgreSQLParserASIN, PostgreSQLParserASIND, PostgreSQLParserATAN, PostgreSQLParserATAND, PostgreSQLParserATAN2, PostgreSQLParserATAN2D, PostgreSQLParserCOS, PostgreSQLParserCOSD, PostgreSQLParserCOT, PostgreSQLParserCOTD, PostgreSQLParserSIN, PostgreSQLParserSIND, PostgreSQLParserTAN, PostgreSQLParserTAND, PostgreSQLParserSINH, PostgreSQLParserCOSH, PostgreSQLParserTANH, PostgreSQLParserASINH, PostgreSQLParserACOSH, PostgreSQLParserATANH, PostgreSQLParserBIT_LENGTH, PostgreSQLParserCHAR_LENGTH, PostgreSQLParserCHARACTER_LENGTH, PostgreSQLParserLOWER, PostgreSQLParserOCTET_LENGTH, PostgreSQLParserUPPER, PostgreSQLParserASCII, PostgreSQLParserBTRIM, PostgreSQLParserCHR, PostgreSQLParserCONCAT, PostgreSQLParserCONCAT_WS, PostgreSQLParserFORMAT, PostgreSQLParserINITCAP, PostgreSQLParserLENGTH, PostgreSQLParserLPAD, PostgreSQLParserLTRIM, PostgreSQLParserMD5, PostgreSQLParserPARSE_IDENT, PostgreSQLParserPG_CLIENT_ENCODING, PostgreSQLParserQUOTE_IDENT, PostgreSQLParserQUOTE_LITERAL, PostgreSQLParserQUOTE_NULLABLE, PostgreSQLParserREGEXP_COUNT, PostgreSQLParserREGEXP_INSTR, PostgreSQLParserREGEXP_LIKE, PostgreSQLParserREGEXP_MATCH, PostgreSQLParserREGEXP_MATCHES, PostgreSQLParserREGEXP_REPLACE, PostgreSQLParserREGEXP_SPLIT_TO_ARRAY, PostgreSQLParserREGEXP_SPLIT_TO_TABLE, PostgreSQLParserREGEXP_SUBSTR, PostgreSQLParserREPEAT, PostgreSQLParserRPAD, PostgreSQLParserRTRIM, PostgreSQLParserSPLIT_PART, PostgreSQLParserSTARTS_WITH, PostgreSQLParserSTRING_TO_ARRAY, PostgreSQLParserSTRING_TO_TABLE, PostgreSQLParserSTRPOS, PostgreSQLParserSUBSTR, PostgreSQLParserTO_ASCII, PostgreSQLParserTO_HEX, PostgreSQLParserTRANSLATE, PostgreSQLParserUNISTR, PostgreSQLParserAGE, PostgreSQLParserCLOCK_TIMESTAMP, PostgreSQLParserDATE_BIN, PostgreSQLParserDATE_PART, PostgreSQLParserDATE_TRUNC, PostgreSQLParserISFINITE, PostgreSQLParserJUSTIFY_DAYS, PostgreSQLParserJUSTIFY_HOURS, PostgreSQLParserJUSTIFY_INTERVAL, PostgreSQLParserMAKE_DATE, PostgreSQLParserMAKE_INTERVAL, PostgreSQLParserMAKE_TIME, PostgreSQLParserMAKE_TIMESTAMP, PostgreSQLParserMAKE_TIMESTAMPTZ, PostgreSQLParserNOW, PostgreSQLParserSTATEMENT_TIMESTAMP, PostgreSQLParserTIMEOFDAY, PostgreSQLParserTRANSACTION_TIMESTAMP, PostgreSQLParserTO_TIMESTAMP, PostgreSQLParserTO_CHAR, PostgreSQLParserTO_DATE, PostgreSQLParserTO_NUMBER, PostgreSQLParserIdentifier, PostgreSQLParserQuotedIdentifier, PostgreSQLParserUnicodeQuotedIdentifier, PostgreSQLParserPLSQLVARIABLENAME, PostgreSQLParserPLSQLIDENTIFIER:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(7875)
			p.Set_target()
		}
		{
			p.SetState(7876)
			p.Match(PostgreSQLParserEQUAL)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(7877)
			p.A_expr()
		}

	case PostgreSQLParserOPEN_PAREN:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(7879)
			p.Match(PostgreSQLParserOPEN_PAREN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(7880)
			p.Set_target_list()
		}
		{
			p.SetState(7881)
			p.Match(PostgreSQLParserCLOSE_PAREN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(7882)
			p.Match(PostgreSQLParserEQUAL)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(7883)
			p.A_expr()
		}

	default:
		p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// ISet_targetContext is an interface to support dynamic dispatch.
type ISet_targetContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Colid() IColidContext
	Opt_indirection() IOpt_indirectionContext

	// IsSet_targetContext differentiates from other interfaces.
	IsSet_targetContext()
}

type Set_targetContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptySet_targetContext() *Set_targetContext {
	var p = new(Set_targetContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_set_target
	return p
}

func InitEmptySet_targetContext(p *Set_targetContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_set_target
}

func (*Set_targetContext) IsSet_targetContext() {}

func NewSet_targetContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Set_targetContext {
	var p = new(Set_targetContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_set_target

	return p
}

func (s *Set_targetContext) GetParser() antlr.Parser { return s.parser }

func (s *Set_targetContext) Colid() IColidContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IColidContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IColidContext)
}

func (s *Set_targetContext) Opt_indirection() IOpt_indirectionContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOpt_indirectionContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOpt_indirectionContext)
}

func (s *Set_targetContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Set_targetContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Set_targetContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterSet_target(s)
	}
}

func (s *Set_targetContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitSet_target(s)
	}
}

func (s *Set_targetContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitSet_target(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Set_target() (localctx ISet_targetContext) {
	localctx = NewSet_targetContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 948, PostgreSQLParserRULE_set_target)
	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(7887)
		p.Colid()
	}
	{
		p.SetState(7888)
		p.Opt_indirection()
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// ISet_target_listContext is an interface to support dynamic dispatch.
type ISet_target_listContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	AllSet_target() []ISet_targetContext
	Set_target(i int) ISet_targetContext
	AllCOMMA() []antlr.TerminalNode
	COMMA(i int) antlr.TerminalNode

	// IsSet_target_listContext differentiates from other interfaces.
	IsSet_target_listContext()
}

type Set_target_listContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptySet_target_listContext() *Set_target_listContext {
	var p = new(Set_target_listContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_set_target_list
	return p
}

func InitEmptySet_target_listContext(p *Set_target_listContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_set_target_list
}

func (*Set_target_listContext) IsSet_target_listContext() {}

func NewSet_target_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Set_target_listContext {
	var p = new(Set_target_listContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_set_target_list

	return p
}

func (s *Set_target_listContext) GetParser() antlr.Parser { return s.parser }

func (s *Set_target_listContext) AllSet_target() []ISet_targetContext {
	children := s.GetChildren()
	len := 0
	for _, ctx := range children {
		if _, ok := ctx.(ISet_targetContext); ok {
			len++
		}
	}

	tst := make([]ISet_targetContext, len)
	i := 0
	for _, ctx := range children {
		if t, ok := ctx.(ISet_targetContext); ok {
			tst[i] = t.(ISet_targetContext)
			i++
		}
	}

	return tst
}

func (s *Set_target_listContext) Set_target(i int) ISet_targetContext {
	var t antlr.RuleContext
	j := 0
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ISet_targetContext); ok {
			if j == i {
				t = ctx.(antlr.RuleContext)
				break
			}
			j++
		}
	}

	if t == nil {
		return nil
	}

	return t.(ISet_targetContext)
}

func (s *Set_target_listContext) AllCOMMA() []antlr.TerminalNode {
	return s.GetTokens(PostgreSQLParserCOMMA)
}

func (s *Set_target_listContext) COMMA(i int) antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCOMMA, i)
}

func (s *Set_target_listContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Set_target_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Set_target_listContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterSet_target_list(s)
	}
}

func (s *Set_target_listContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitSet_target_list(s)
	}
}

func (s *Set_target_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitSet_target_list(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Set_target_list() (localctx ISet_target_listContext) {
	localctx = NewSet_target_listContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 950, PostgreSQLParserRULE_set_target_list)
	var _la int

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(7890)
		p.Set_target()
	}
	p.SetState(7895)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}
	_la = p.GetTokenStream().LA(1)

	for _la == PostgreSQLParserCOMMA {
		{
			p.SetState(7891)
			p.Match(PostgreSQLParserCOMMA)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(7892)
			p.Set_target()
		}

		p.SetState(7897)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}
		_la = p.GetTokenStream().LA(1)
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IDeclarecursorstmtContext is an interface to support dynamic dispatch.
type IDeclarecursorstmtContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	DECLARE() antlr.TerminalNode
	Cursor_name() ICursor_nameContext
	Cursor_options() ICursor_optionsContext
	CURSOR() antlr.TerminalNode
	Opt_hold() IOpt_holdContext
	FOR() antlr.TerminalNode
	Selectstmt() ISelectstmtContext

	// IsDeclarecursorstmtContext differentiates from other interfaces.
	IsDeclarecursorstmtContext()
}

type DeclarecursorstmtContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyDeclarecursorstmtContext() *DeclarecursorstmtContext {
	var p = new(DeclarecursorstmtContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_declarecursorstmt
	return p
}

func InitEmptyDeclarecursorstmtContext(p *DeclarecursorstmtContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_declarecursorstmt
}

func (*DeclarecursorstmtContext) IsDeclarecursorstmtContext() {}

func NewDeclarecursorstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DeclarecursorstmtContext {
	var p = new(DeclarecursorstmtContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_declarecursorstmt

	return p
}

func (s *DeclarecursorstmtContext) GetParser() antlr.Parser { return s.parser }

func (s *DeclarecursorstmtContext) DECLARE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserDECLARE, 0)
}

func (s *DeclarecursorstmtContext) Cursor_name() ICursor_nameContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ICursor_nameContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ICursor_nameContext)
}

func (s *DeclarecursorstmtContext) Cursor_options() ICursor_optionsContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ICursor_optionsContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ICursor_optionsContext)
}

func (s *DeclarecursorstmtContext) CURSOR() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCURSOR, 0)
}

func (s *DeclarecursorstmtContext) Opt_hold() IOpt_holdContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOpt_holdContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOpt_holdContext)
}

func (s *DeclarecursorstmtContext) FOR() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserFOR, 0)
}

func (s *DeclarecursorstmtContext) Selectstmt() ISelectstmtContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ISelectstmtContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ISelectstmtContext)
}

func (s *DeclarecursorstmtContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *DeclarecursorstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *DeclarecursorstmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterDeclarecursorstmt(s)
	}
}

func (s *DeclarecursorstmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitDeclarecursorstmt(s)
	}
}

func (s *DeclarecursorstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitDeclarecursorstmt(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Declarecursorstmt() (localctx IDeclarecursorstmtContext) {
	localctx = NewDeclarecursorstmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 952, PostgreSQLParserRULE_declarecursorstmt)
	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(7898)
		p.Match(PostgreSQLParserDECLARE)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(7899)
		p.Cursor_name()
	}
	{
		p.SetState(7900)
		p.Cursor_options()
	}
	{
		p.SetState(7901)
		p.Match(PostgreSQLParserCURSOR)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(7902)
		p.Opt_hold()
	}
	{
		p.SetState(7903)
		p.Match(PostgreSQLParserFOR)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(7904)
		p.Selectstmt()
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// ICursor_nameContext is an interface to support dynamic dispatch.
type ICursor_nameContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Name() INameContext

	// IsCursor_nameContext differentiates from other interfaces.
	IsCursor_nameContext()
}

type Cursor_nameContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyCursor_nameContext() *Cursor_nameContext {
	var p = new(Cursor_nameContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_cursor_name
	return p
}

func InitEmptyCursor_nameContext(p *Cursor_nameContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_cursor_name
}

func (*Cursor_nameContext) IsCursor_nameContext() {}

func NewCursor_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Cursor_nameContext {
	var p = new(Cursor_nameContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_cursor_name

	return p
}

func (s *Cursor_nameContext) GetParser() antlr.Parser { return s.parser }

func (s *Cursor_nameContext) Name() INameContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(INameContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(INameContext)
}

func (s *Cursor_nameContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Cursor_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Cursor_nameContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterCursor_name(s)
	}
}

func (s *Cursor_nameContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitCursor_name(s)
	}
}

func (s *Cursor_nameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitCursor_name(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Cursor_name() (localctx ICursor_nameContext) {
	localctx = NewCursor_nameContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 954, PostgreSQLParserRULE_cursor_name)
	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(7906)
		p.Name()
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// ICursor_optionsContext is an interface to support dynamic dispatch.
type ICursor_optionsContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	AllNO() []antlr.TerminalNode
	NO(i int) antlr.TerminalNode
	AllSCROLL() []antlr.TerminalNode
	SCROLL(i int) antlr.TerminalNode
	AllBINARY() []antlr.TerminalNode
	BINARY(i int) antlr.TerminalNode
	AllINSENSITIVE() []antlr.TerminalNode
	INSENSITIVE(i int) antlr.TerminalNode

	// IsCursor_optionsContext differentiates from other interfaces.
	IsCursor_optionsContext()
}

type Cursor_optionsContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyCursor_optionsContext() *Cursor_optionsContext {
	var p = new(Cursor_optionsContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_cursor_options
	return p
}

func InitEmptyCursor_optionsContext(p *Cursor_optionsContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_cursor_options
}

func (*Cursor_optionsContext) IsCursor_optionsContext() {}

func NewCursor_optionsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Cursor_optionsContext {
	var p = new(Cursor_optionsContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_cursor_options

	return p
}

func (s *Cursor_optionsContext) GetParser() antlr.Parser { return s.parser }

func (s *Cursor_optionsContext) AllNO() []antlr.TerminalNode {
	return s.GetTokens(PostgreSQLParserNO)
}

func (s *Cursor_optionsContext) NO(i int) antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserNO, i)
}

func (s *Cursor_optionsContext) AllSCROLL() []antlr.TerminalNode {
	return s.GetTokens(PostgreSQLParserSCROLL)
}

func (s *Cursor_optionsContext) SCROLL(i int) antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserSCROLL, i)
}

func (s *Cursor_optionsContext) AllBINARY() []antlr.TerminalNode {
	return s.GetTokens(PostgreSQLParserBINARY)
}

func (s *Cursor_optionsContext) BINARY(i int) antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserBINARY, i)
}

func (s *Cursor_optionsContext) AllINSENSITIVE() []antlr.TerminalNode {
	return s.GetTokens(PostgreSQLParserINSENSITIVE)
}

func (s *Cursor_optionsContext) INSENSITIVE(i int) antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserINSENSITIVE, i)
}

func (s *Cursor_optionsContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Cursor_optionsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Cursor_optionsContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterCursor_options(s)
	}
}

func (s *Cursor_optionsContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitCursor_options(s)
	}
}

func (s *Cursor_optionsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitCursor_options(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Cursor_options() (localctx ICursor_optionsContext) {
	localctx = NewCursor_optionsContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 956, PostgreSQLParserRULE_cursor_options)
	var _la int

	p.EnterOuterAlt(localctx, 1)
	p.SetState(7915)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}
	_la = p.GetTokenStream().LA(1)

	for _la == PostgreSQLParserBINARY || _la == PostgreSQLParserINSENSITIVE || _la == PostgreSQLParserNO || _la == PostgreSQLParserSCROLL {
		p.SetState(7913)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}

		switch p.GetTokenStream().LA(1) {
		case PostgreSQLParserNO:
			{
				p.SetState(7908)
				p.Match(PostgreSQLParserNO)
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}
			{
				p.SetState(7909)
				p.Match(PostgreSQLParserSCROLL)
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}

		case PostgreSQLParserSCROLL:
			{
				p.SetState(7910)
				p.Match(PostgreSQLParserSCROLL)
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}

		case PostgreSQLParserBINARY:
			{
				p.SetState(7911)
				p.Match(PostgreSQLParserBINARY)
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}

		case PostgreSQLParserINSENSITIVE:
			{
				p.SetState(7912)
				p.Match(PostgreSQLParserINSENSITIVE)
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}

		default:
			p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
			goto errorExit
		}

		p.SetState(7917)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}
		_la = p.GetTokenStream().LA(1)
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IOpt_holdContext is an interface to support dynamic dispatch.
type IOpt_holdContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	WITH() antlr.TerminalNode
	HOLD() antlr.TerminalNode
	WITHOUT() antlr.TerminalNode

	// IsOpt_holdContext differentiates from other interfaces.
	IsOpt_holdContext()
}

type Opt_holdContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyOpt_holdContext() *Opt_holdContext {
	var p = new(Opt_holdContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opt_hold
	return p
}

func InitEmptyOpt_holdContext(p *Opt_holdContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opt_hold
}

func (*Opt_holdContext) IsOpt_holdContext() {}

func NewOpt_holdContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_holdContext {
	var p = new(Opt_holdContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_opt_hold

	return p
}

func (s *Opt_holdContext) GetParser() antlr.Parser { return s.parser }

func (s *Opt_holdContext) WITH() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserWITH, 0)
}

func (s *Opt_holdContext) HOLD() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserHOLD, 0)
}

func (s *Opt_holdContext) WITHOUT() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserWITHOUT, 0)
}

func (s *Opt_holdContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Opt_holdContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Opt_holdContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterOpt_hold(s)
	}
}

func (s *Opt_holdContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitOpt_hold(s)
	}
}

func (s *Opt_holdContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitOpt_hold(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Opt_hold() (localctx IOpt_holdContext) {
	localctx = NewOpt_holdContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 958, PostgreSQLParserRULE_opt_hold)
	p.SetState(7923)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetTokenStream().LA(1) {
	case PostgreSQLParserFOR:
		p.EnterOuterAlt(localctx, 1)

	case PostgreSQLParserWITH:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(7919)
			p.Match(PostgreSQLParserWITH)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(7920)
			p.Match(PostgreSQLParserHOLD)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case PostgreSQLParserWITHOUT:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(7921)
			p.Match(PostgreSQLParserWITHOUT)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(7922)
			p.Match(PostgreSQLParserHOLD)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	default:
		p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// ISelectstmtContext is an interface to support dynamic dispatch.
type ISelectstmtContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Select_no_parens() ISelect_no_parensContext
	Select_with_parens() ISelect_with_parensContext

	// IsSelectstmtContext differentiates from other interfaces.
	IsSelectstmtContext()
}

type SelectstmtContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptySelectstmtContext() *SelectstmtContext {
	var p = new(SelectstmtContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_selectstmt
	return p
}

func InitEmptySelectstmtContext(p *SelectstmtContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_selectstmt
}

func (*SelectstmtContext) IsSelectstmtContext() {}

func NewSelectstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SelectstmtContext {
	var p = new(SelectstmtContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_selectstmt

	return p
}

func (s *SelectstmtContext) GetParser() antlr.Parser { return s.parser }

func (s *SelectstmtContext) Select_no_parens() ISelect_no_parensContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ISelect_no_parensContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ISelect_no_parensContext)
}

func (s *SelectstmtContext) Select_with_parens() ISelect_with_parensContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ISelect_with_parensContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ISelect_with_parensContext)
}

func (s *SelectstmtContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *SelectstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *SelectstmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterSelectstmt(s)
	}
}

func (s *SelectstmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitSelectstmt(s)
	}
}

func (s *SelectstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitSelectstmt(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Selectstmt() (localctx ISelectstmtContext) {
	localctx = NewSelectstmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 960, PostgreSQLParserRULE_selectstmt)
	p.SetState(7927)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 416, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(7925)
			p.Select_no_parens()
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(7926)
			p.Select_with_parens()
		}

	case antlr.ATNInvalidAltNumber:
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// ISelect_with_parensContext is an interface to support dynamic dispatch.
type ISelect_with_parensContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	OPEN_PAREN() antlr.TerminalNode
	Select_no_parens() ISelect_no_parensContext
	CLOSE_PAREN() antlr.TerminalNode
	Select_with_parens() ISelect_with_parensContext

	// IsSelect_with_parensContext differentiates from other interfaces.
	IsSelect_with_parensContext()
}

type Select_with_parensContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptySelect_with_parensContext() *Select_with_parensContext {
	var p = new(Select_with_parensContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_select_with_parens
	return p
}

func InitEmptySelect_with_parensContext(p *Select_with_parensContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_select_with_parens
}

func (*Select_with_parensContext) IsSelect_with_parensContext() {}

func NewSelect_with_parensContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Select_with_parensContext {
	var p = new(Select_with_parensContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_select_with_parens

	return p
}

func (s *Select_with_parensContext) GetParser() antlr.Parser { return s.parser }

func (s *Select_with_parensContext) OPEN_PAREN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserOPEN_PAREN, 0)
}

func (s *Select_with_parensContext) Select_no_parens() ISelect_no_parensContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ISelect_no_parensContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ISelect_no_parensContext)
}

func (s *Select_with_parensContext) CLOSE_PAREN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCLOSE_PAREN, 0)
}

func (s *Select_with_parensContext) Select_with_parens() ISelect_with_parensContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ISelect_with_parensContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ISelect_with_parensContext)
}

func (s *Select_with_parensContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Select_with_parensContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Select_with_parensContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterSelect_with_parens(s)
	}
}

func (s *Select_with_parensContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitSelect_with_parens(s)
	}
}

func (s *Select_with_parensContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitSelect_with_parens(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Select_with_parens() (localctx ISelect_with_parensContext) {
	localctx = NewSelect_with_parensContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 962, PostgreSQLParserRULE_select_with_parens)
	p.SetState(7937)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 417, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(7929)
			p.Match(PostgreSQLParserOPEN_PAREN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(7930)
			p.Select_no_parens()
		}
		{
			p.SetState(7931)
			p.Match(PostgreSQLParserCLOSE_PAREN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(7933)
			p.Match(PostgreSQLParserOPEN_PAREN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(7934)
			p.Select_with_parens()
		}
		{
			p.SetState(7935)
			p.Match(PostgreSQLParserCLOSE_PAREN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case antlr.ATNInvalidAltNumber:
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// ISelect_no_parensContext is an interface to support dynamic dispatch.
type ISelect_no_parensContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Select_clause() ISelect_clauseContext
	Opt_sort_clause() IOpt_sort_clauseContext
	For_locking_clause() IFor_locking_clauseContext
	Opt_select_limit() IOpt_select_limitContext
	Select_limit() ISelect_limitContext
	Opt_for_locking_clause() IOpt_for_locking_clauseContext
	With_clause() IWith_clauseContext

	// IsSelect_no_parensContext differentiates from other interfaces.
	IsSelect_no_parensContext()
}

type Select_no_parensContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptySelect_no_parensContext() *Select_no_parensContext {
	var p = new(Select_no_parensContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_select_no_parens
	return p
}

func InitEmptySelect_no_parensContext(p *Select_no_parensContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_select_no_parens
}

func (*Select_no_parensContext) IsSelect_no_parensContext() {}

func NewSelect_no_parensContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Select_no_parensContext {
	var p = new(Select_no_parensContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_select_no_parens

	return p
}

func (s *Select_no_parensContext) GetParser() antlr.Parser { return s.parser }

func (s *Select_no_parensContext) Select_clause() ISelect_clauseContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ISelect_clauseContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ISelect_clauseContext)
}

func (s *Select_no_parensContext) Opt_sort_clause() IOpt_sort_clauseContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOpt_sort_clauseContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOpt_sort_clauseContext)
}

func (s *Select_no_parensContext) For_locking_clause() IFor_locking_clauseContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IFor_locking_clauseContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IFor_locking_clauseContext)
}

func (s *Select_no_parensContext) Opt_select_limit() IOpt_select_limitContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOpt_select_limitContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOpt_select_limitContext)
}

func (s *Select_no_parensContext) Select_limit() ISelect_limitContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ISelect_limitContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ISelect_limitContext)
}

func (s *Select_no_parensContext) Opt_for_locking_clause() IOpt_for_locking_clauseContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOpt_for_locking_clauseContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOpt_for_locking_clauseContext)
}

func (s *Select_no_parensContext) With_clause() IWith_clauseContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IWith_clauseContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IWith_clauseContext)
}

func (s *Select_no_parensContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Select_no_parensContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Select_no_parensContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterSelect_no_parens(s)
	}
}

func (s *Select_no_parensContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitSelect_no_parens(s)
	}
}

func (s *Select_no_parensContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitSelect_no_parens(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Select_no_parens() (localctx ISelect_no_parensContext) {
	localctx = NewSelect_no_parensContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 964, PostgreSQLParserRULE_select_no_parens)
	p.SetState(7960)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetTokenStream().LA(1) {
	case PostgreSQLParserOPEN_PAREN, PostgreSQLParserSELECT, PostgreSQLParserTABLE, PostgreSQLParserVALUES:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(7939)
			p.Select_clause()
		}
		{
			p.SetState(7940)
			p.Opt_sort_clause()
		}
		p.SetState(7947)
		p.GetErrorHandler().Sync(p)

		if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 418, p.GetParserRuleContext()) == 1 {
			{
				p.SetState(7941)
				p.For_locking_clause()
			}
			{
				p.SetState(7942)
				p.Opt_select_limit()
			}

		} else if p.HasError() { // JIM
			goto errorExit
		} else if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 418, p.GetParserRuleContext()) == 2 {
			{
				p.SetState(7944)
				p.Select_limit()
			}
			{
				p.SetState(7945)
				p.Opt_for_locking_clause()
			}

		} else if p.HasError() { // JIM
			goto errorExit
		}

	case PostgreSQLParserWITH:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(7949)
			p.With_clause()
		}
		{
			p.SetState(7950)
			p.Select_clause()
		}
		{
			p.SetState(7951)
			p.Opt_sort_clause()
		}
		p.SetState(7958)
		p.GetErrorHandler().Sync(p)

		if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 419, p.GetParserRuleContext()) == 1 {
			{
				p.SetState(7952)
				p.For_locking_clause()
			}
			{
				p.SetState(7953)
				p.Opt_select_limit()
			}

		} else if p.HasError() { // JIM
			goto errorExit
		} else if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 419, p.GetParserRuleContext()) == 2 {
			{
				p.SetState(7955)
				p.Select_limit()
			}
			{
				p.SetState(7956)
				p.Opt_for_locking_clause()
			}

		} else if p.HasError() { // JIM
			goto errorExit
		}

	default:
		p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// ISelect_clauseContext is an interface to support dynamic dispatch.
type ISelect_clauseContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	AllSimple_select_intersect() []ISimple_select_intersectContext
	Simple_select_intersect(i int) ISimple_select_intersectContext
	AllAll_or_distinct() []IAll_or_distinctContext
	All_or_distinct(i int) IAll_or_distinctContext
	AllUNION() []antlr.TerminalNode
	UNION(i int) antlr.TerminalNode
	AllEXCEPT() []antlr.TerminalNode
	EXCEPT(i int) antlr.TerminalNode

	// IsSelect_clauseContext differentiates from other interfaces.
	IsSelect_clauseContext()
}

type Select_clauseContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptySelect_clauseContext() *Select_clauseContext {
	var p = new(Select_clauseContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_select_clause
	return p
}

func InitEmptySelect_clauseContext(p *Select_clauseContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_select_clause
}

func (*Select_clauseContext) IsSelect_clauseContext() {}

func NewSelect_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Select_clauseContext {
	var p = new(Select_clauseContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_select_clause

	return p
}

func (s *Select_clauseContext) GetParser() antlr.Parser { return s.parser }

func (s *Select_clauseContext) AllSimple_select_intersect() []ISimple_select_intersectContext {
	children := s.GetChildren()
	len := 0
	for _, ctx := range children {
		if _, ok := ctx.(ISimple_select_intersectContext); ok {
			len++
		}
	}

	tst := make([]ISimple_select_intersectContext, len)
	i := 0
	for _, ctx := range children {
		if t, ok := ctx.(ISimple_select_intersectContext); ok {
			tst[i] = t.(ISimple_select_intersectContext)
			i++
		}
	}

	return tst
}

func (s *Select_clauseContext) Simple_select_intersect(i int) ISimple_select_intersectContext {
	var t antlr.RuleContext
	j := 0
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ISimple_select_intersectContext); ok {
			if j == i {
				t = ctx.(antlr.RuleContext)
				break
			}
			j++
		}
	}

	if t == nil {
		return nil
	}

	return t.(ISimple_select_intersectContext)
}

func (s *Select_clauseContext) AllAll_or_distinct() []IAll_or_distinctContext {
	children := s.GetChildren()
	len := 0
	for _, ctx := range children {
		if _, ok := ctx.(IAll_or_distinctContext); ok {
			len++
		}
	}

	tst := make([]IAll_or_distinctContext, len)
	i := 0
	for _, ctx := range children {
		if t, ok := ctx.(IAll_or_distinctContext); ok {
			tst[i] = t.(IAll_or_distinctContext)
			i++
		}
	}

	return tst
}

func (s *Select_clauseContext) All_or_distinct(i int) IAll_or_distinctContext {
	var t antlr.RuleContext
	j := 0
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IAll_or_distinctContext); ok {
			if j == i {
				t = ctx.(antlr.RuleContext)
				break
			}
			j++
		}
	}

	if t == nil {
		return nil
	}

	return t.(IAll_or_distinctContext)
}

func (s *Select_clauseContext) AllUNION() []antlr.TerminalNode {
	return s.GetTokens(PostgreSQLParserUNION)
}

func (s *Select_clauseContext) UNION(i int) antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserUNION, i)
}

func (s *Select_clauseContext) AllEXCEPT() []antlr.TerminalNode {
	return s.GetTokens(PostgreSQLParserEXCEPT)
}

func (s *Select_clauseContext) EXCEPT(i int) antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserEXCEPT, i)
}

func (s *Select_clauseContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Select_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Select_clauseContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterSelect_clause(s)
	}
}

func (s *Select_clauseContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitSelect_clause(s)
	}
}

func (s *Select_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitSelect_clause(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Select_clause() (localctx ISelect_clauseContext) {
	localctx = NewSelect_clauseContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 966, PostgreSQLParserRULE_select_clause)
	var _la int

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(7962)
		p.Simple_select_intersect()
	}
	p.SetState(7969)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}
	_la = p.GetTokenStream().LA(1)

	for _la == PostgreSQLParserEXCEPT || _la == PostgreSQLParserUNION {
		{
			p.SetState(7963)
			_la = p.GetTokenStream().LA(1)

			if !(_la == PostgreSQLParserEXCEPT || _la == PostgreSQLParserUNION) {
				p.GetErrorHandler().RecoverInline(p)
			} else {
				p.GetErrorHandler().ReportMatch(p)
				p.Consume()
			}
		}
		{
			p.SetState(7964)
			p.All_or_distinct()
		}
		{
			p.SetState(7965)
			p.Simple_select_intersect()
		}

		p.SetState(7971)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}
		_la = p.GetTokenStream().LA(1)
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// ISimple_select_intersectContext is an interface to support dynamic dispatch.
type ISimple_select_intersectContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	AllSimple_select_pramary() []ISimple_select_pramaryContext
	Simple_select_pramary(i int) ISimple_select_pramaryContext
	AllINTERSECT() []antlr.TerminalNode
	INTERSECT(i int) antlr.TerminalNode
	AllAll_or_distinct() []IAll_or_distinctContext
	All_or_distinct(i int) IAll_or_distinctContext

	// IsSimple_select_intersectContext differentiates from other interfaces.
	IsSimple_select_intersectContext()
}

type Simple_select_intersectContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptySimple_select_intersectContext() *Simple_select_intersectContext {
	var p = new(Simple_select_intersectContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_simple_select_intersect
	return p
}

func InitEmptySimple_select_intersectContext(p *Simple_select_intersectContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_simple_select_intersect
}

func (*Simple_select_intersectContext) IsSimple_select_intersectContext() {}

func NewSimple_select_intersectContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Simple_select_intersectContext {
	var p = new(Simple_select_intersectContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_simple_select_intersect

	return p
}

func (s *Simple_select_intersectContext) GetParser() antlr.Parser { return s.parser }

func (s *Simple_select_intersectContext) AllSimple_select_pramary() []ISimple_select_pramaryContext {
	children := s.GetChildren()
	len := 0
	for _, ctx := range children {
		if _, ok := ctx.(ISimple_select_pramaryContext); ok {
			len++
		}
	}

	tst := make([]ISimple_select_pramaryContext, len)
	i := 0
	for _, ctx := range children {
		if t, ok := ctx.(ISimple_select_pramaryContext); ok {
			tst[i] = t.(ISimple_select_pramaryContext)
			i++
		}
	}

	return tst
}

func (s *Simple_select_intersectContext) Simple_select_pramary(i int) ISimple_select_pramaryContext {
	var t antlr.RuleContext
	j := 0
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ISimple_select_pramaryContext); ok {
			if j == i {
				t = ctx.(antlr.RuleContext)
				break
			}
			j++
		}
	}

	if t == nil {
		return nil
	}

	return t.(ISimple_select_pramaryContext)
}

func (s *Simple_select_intersectContext) AllINTERSECT() []antlr.TerminalNode {
	return s.GetTokens(PostgreSQLParserINTERSECT)
}

func (s *Simple_select_intersectContext) INTERSECT(i int) antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserINTERSECT, i)
}

func (s *Simple_select_intersectContext) AllAll_or_distinct() []IAll_or_distinctContext {
	children := s.GetChildren()
	len := 0
	for _, ctx := range children {
		if _, ok := ctx.(IAll_or_distinctContext); ok {
			len++
		}
	}

	tst := make([]IAll_or_distinctContext, len)
	i := 0
	for _, ctx := range children {
		if t, ok := ctx.(IAll_or_distinctContext); ok {
			tst[i] = t.(IAll_or_distinctContext)
			i++
		}
	}

	return tst
}

func (s *Simple_select_intersectContext) All_or_distinct(i int) IAll_or_distinctContext {
	var t antlr.RuleContext
	j := 0
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IAll_or_distinctContext); ok {
			if j == i {
				t = ctx.(antlr.RuleContext)
				break
			}
			j++
		}
	}

	if t == nil {
		return nil
	}

	return t.(IAll_or_distinctContext)
}

func (s *Simple_select_intersectContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Simple_select_intersectContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Simple_select_intersectContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterSimple_select_intersect(s)
	}
}

func (s *Simple_select_intersectContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitSimple_select_intersect(s)
	}
}

func (s *Simple_select_intersectContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitSimple_select_intersect(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Simple_select_intersect() (localctx ISimple_select_intersectContext) {
	localctx = NewSimple_select_intersectContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 968, PostgreSQLParserRULE_simple_select_intersect)
	var _la int

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(7972)
		p.Simple_select_pramary()
	}
	p.SetState(7979)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}
	_la = p.GetTokenStream().LA(1)

	for _la == PostgreSQLParserINTERSECT {
		{
			p.SetState(7973)
			p.Match(PostgreSQLParserINTERSECT)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(7974)
			p.All_or_distinct()
		}
		{
			p.SetState(7975)
			p.Simple_select_pramary()
		}

		p.SetState(7981)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}
		_la = p.GetTokenStream().LA(1)
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// ISimple_select_pramaryContext is an interface to support dynamic dispatch.
type ISimple_select_pramaryContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	SELECT() antlr.TerminalNode
	AllInto_clause() []IInto_clauseContext
	Into_clause(i int) IInto_clauseContext
	From_clause() IFrom_clauseContext
	Where_clause() IWhere_clauseContext
	Group_clause() IGroup_clauseContext
	Having_clause() IHaving_clauseContext
	Window_clause() IWindow_clauseContext
	Opt_all_clause() IOpt_all_clauseContext
	Opt_target_list() IOpt_target_listContext
	Distinct_clause() IDistinct_clauseContext
	Target_list() ITarget_listContext
	Values_clause() IValues_clauseContext
	TABLE() antlr.TerminalNode
	Relation_expr() IRelation_exprContext
	Select_with_parens() ISelect_with_parensContext

	// IsSimple_select_pramaryContext differentiates from other interfaces.
	IsSimple_select_pramaryContext()
}

type Simple_select_pramaryContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptySimple_select_pramaryContext() *Simple_select_pramaryContext {
	var p = new(Simple_select_pramaryContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_simple_select_pramary
	return p
}

func InitEmptySimple_select_pramaryContext(p *Simple_select_pramaryContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_simple_select_pramary
}

func (*Simple_select_pramaryContext) IsSimple_select_pramaryContext() {}

func NewSimple_select_pramaryContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Simple_select_pramaryContext {
	var p = new(Simple_select_pramaryContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_simple_select_pramary

	return p
}

func (s *Simple_select_pramaryContext) GetParser() antlr.Parser { return s.parser }

func (s *Simple_select_pramaryContext) SELECT() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserSELECT, 0)
}

func (s *Simple_select_pramaryContext) AllInto_clause() []IInto_clauseContext {
	children := s.GetChildren()
	len := 0
	for _, ctx := range children {
		if _, ok := ctx.(IInto_clauseContext); ok {
			len++
		}
	}

	tst := make([]IInto_clauseContext, len)
	i := 0
	for _, ctx := range children {
		if t, ok := ctx.(IInto_clauseContext); ok {
			tst[i] = t.(IInto_clauseContext)
			i++
		}
	}

	return tst
}

func (s *Simple_select_pramaryContext) Into_clause(i int) IInto_clauseContext {
	var t antlr.RuleContext
	j := 0
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IInto_clauseContext); ok {
			if j == i {
				t = ctx.(antlr.RuleContext)
				break
			}
			j++
		}
	}

	if t == nil {
		return nil
	}

	return t.(IInto_clauseContext)
}

func (s *Simple_select_pramaryContext) From_clause() IFrom_clauseContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IFrom_clauseContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IFrom_clauseContext)
}

func (s *Simple_select_pramaryContext) Where_clause() IWhere_clauseContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IWhere_clauseContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IWhere_clauseContext)
}

func (s *Simple_select_pramaryContext) Group_clause() IGroup_clauseContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IGroup_clauseContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IGroup_clauseContext)
}

func (s *Simple_select_pramaryContext) Having_clause() IHaving_clauseContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IHaving_clauseContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IHaving_clauseContext)
}

func (s *Simple_select_pramaryContext) Window_clause() IWindow_clauseContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IWindow_clauseContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IWindow_clauseContext)
}

func (s *Simple_select_pramaryContext) Opt_all_clause() IOpt_all_clauseContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOpt_all_clauseContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOpt_all_clauseContext)
}

func (s *Simple_select_pramaryContext) Opt_target_list() IOpt_target_listContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOpt_target_listContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOpt_target_listContext)
}

func (s *Simple_select_pramaryContext) Distinct_clause() IDistinct_clauseContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IDistinct_clauseContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IDistinct_clauseContext)
}

func (s *Simple_select_pramaryContext) Target_list() ITarget_listContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ITarget_listContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ITarget_listContext)
}

func (s *Simple_select_pramaryContext) Values_clause() IValues_clauseContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IValues_clauseContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IValues_clauseContext)
}

func (s *Simple_select_pramaryContext) TABLE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserTABLE, 0)
}

func (s *Simple_select_pramaryContext) Relation_expr() IRelation_exprContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IRelation_exprContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IRelation_exprContext)
}

func (s *Simple_select_pramaryContext) Select_with_parens() ISelect_with_parensContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ISelect_with_parensContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ISelect_with_parensContext)
}

func (s *Simple_select_pramaryContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Simple_select_pramaryContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Simple_select_pramaryContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterSimple_select_pramary(s)
	}
}

func (s *Simple_select_pramaryContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitSimple_select_pramary(s)
	}
}

func (s *Simple_select_pramaryContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitSimple_select_pramary(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Simple_select_pramary() (localctx ISimple_select_pramaryContext) {
	localctx = NewSimple_select_pramaryContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 970, PostgreSQLParserRULE_simple_select_pramary)
	p.SetState(8003)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetTokenStream().LA(1) {
	case PostgreSQLParserSELECT:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(7982)
			p.Match(PostgreSQLParserSELECT)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		p.SetState(7990)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}

		switch p.GetTokenStream().LA(1) {
		case PostgreSQLParserEOF, PostgreSQLParserOPEN_PAREN, PostgreSQLParserCLOSE_PAREN, PostgreSQLParserSEMI, PostgreSQLParserSTAR, PostgreSQLParserPLUS, PostgreSQLParserMINUS, PostgreSQLParserPARAM, PostgreSQLParserOperator, PostgreSQLParserALL, PostgreSQLParserANALYSE, PostgreSQLParserANALYZE, PostgreSQLParserAND, PostgreSQLParserARRAY, PostgreSQLParserCASE, PostgreSQLParserCAST, PostgreSQLParserCOLLATE, PostgreSQLParserCOLUMN, PostgreSQLParserCONSTRAINT, PostgreSQLParserCREATE, PostgreSQLParserCURRENT_CATALOG, PostgreSQLParserCURRENT_DATE, PostgreSQLParserCURRENT_ROLE, PostgreSQLParserCURRENT_TIME, PostgreSQLParserCURRENT_TIMESTAMP, PostgreSQLParserCURRENT_USER, PostgreSQLParserDEFAULT, PostgreSQLParserDO, PostgreSQLParserEXCEPT, PostgreSQLParserFALSE_P, PostgreSQLParserFETCH, PostgreSQLParserFOR, PostgreSQLParserFROM, PostgreSQLParserGRANT, PostgreSQLParserGROUP_P, PostgreSQLParserHAVING, PostgreSQLParserINTERSECT, PostgreSQLParserINTO, PostgreSQLParserLIMIT, PostgreSQLParserLOCALTIME, PostgreSQLParserLOCALTIMESTAMP, PostgreSQLParserNOT, PostgreSQLParserNULL_P, PostgreSQLParserOFFSET, PostgreSQLParserON, PostgreSQLParserORDER, PostgreSQLParserRETURNING, PostgreSQLParserSELECT, PostgreSQLParserSESSION_USER, PostgreSQLParserTABLE, PostgreSQLParserTRUE_P, PostgreSQLParserUNION, PostgreSQLParserUNIQUE, PostgreSQLParserUSER, PostgreSQLParserWHERE, PostgreSQLParserWINDOW, PostgreSQLParserWITH, PostgreSQLParserAUTHORIZATION, PostgreSQLParserBINARY, PostgreSQLParserCOLLATION, PostgreSQLParserCONCURRENTLY, PostgreSQLParserCROSS, PostgreSQLParserCURRENT_SCHEMA, PostgreSQLParserFREEZE, PostgreSQLParserFULL, PostgreSQLParserILIKE, PostgreSQLParserINNER_P, PostgreSQLParserIS, PostgreSQLParserISNULL, PostgreSQLParserJOIN, PostgreSQLParserLEFT, PostgreSQLParserLIKE, PostgreSQLParserNATURAL, PostgreSQLParserNOTNULL, PostgreSQLParserOUTER_P, PostgreSQLParserOVER, PostgreSQLParserOVERLAPS, PostgreSQLParserRIGHT, PostgreSQLParserSIMILAR, PostgreSQLParserVERBOSE, PostgreSQLParserABORT_P, PostgreSQLParserABSOLUTE_P, PostgreSQLParserACCESS, PostgreSQLParserACTION, PostgreSQLParserADD_P, PostgreSQLParserADMIN, PostgreSQLParserAFTER, PostgreSQLParserAGGREGATE, PostgreSQLParserALSO, PostgreSQLParserALTER, PostgreSQLParserALWAYS, PostgreSQLParserASSERTION, PostgreSQLParserASSIGNMENT, PostgreSQLParserAT, PostgreSQLParserATTRIBUTE, PostgreSQLParserBACKWARD, PostgreSQLParserBEFORE, PostgreSQLParserBEGIN_P, PostgreSQLParserBY, PostgreSQLParserCACHE, PostgreSQLParserCALLED, PostgreSQLParserCASCADE, PostgreSQLParserCASCADED, PostgreSQLParserCATALOG, PostgreSQLParserCHAIN, PostgreSQLParserCHARACTERISTICS, PostgreSQLParserCHECKPOINT, PostgreSQLParserCLASS, PostgreSQLParserCLOSE, PostgreSQLParserCLUSTER, PostgreSQLParserCOMMENT, PostgreSQLParserCOMMENTS, PostgreSQLParserCOMMIT, PostgreSQLParserCOMMITTED, PostgreSQLParserCONFIGURATION, PostgreSQLParserCONNECTION, PostgreSQLParserCONSTRAINTS, PostgreSQLParserCONTENT_P, PostgreSQLParserCONTINUE_P, PostgreSQLParserCONVERSION_P, PostgreSQLParserCOPY, PostgreSQLParserCOST, PostgreSQLParserCSV, PostgreSQLParserCURSOR, PostgreSQLParserCYCLE, PostgreSQLParserDATA_P, PostgreSQLParserDATABASE, PostgreSQLParserDAY_P, PostgreSQLParserDEALLOCATE, PostgreSQLParserDECLARE, PostgreSQLParserDEFAULTS, PostgreSQLParserDEFERRED, PostgreSQLParserDEFINER, PostgreSQLParserDELETE_P, PostgreSQLParserDELIMITER, PostgreSQLParserDELIMITERS, PostgreSQLParserDICTIONARY, PostgreSQLParserDISABLE_P, PostgreSQLParserDISCARD, PostgreSQLParserDOCUMENT_P, PostgreSQLParserDOMAIN_P, PostgreSQLParserDOUBLE_P, PostgreSQLParserDROP, PostgreSQLParserEACH, PostgreSQLParserENABLE_P, PostgreSQLParserENCODING, PostgreSQLParserENCRYPTED, PostgreSQLParserENUM_P, PostgreSQLParserESCAPE, PostgreSQLParserEVENT, PostgreSQLParserEXCLUDE, PostgreSQLParserEXCLUDING, PostgreSQLParserEXCLUSIVE, PostgreSQLParserEXECUTE, PostgreSQLParserEXPLAIN, PostgreSQLParserEXTENSION, PostgreSQLParserEXTERNAL, PostgreSQLParserFAMILY, PostgreSQLParserFIRST_P, PostgreSQLParserFOLLOWING, PostgreSQLParserFORCE, PostgreSQLParserFORWARD, PostgreSQLParserFUNCTION, PostgreSQLParserFUNCTIONS, PostgreSQLParserGLOBAL, PostgreSQLParserGRANTED, PostgreSQLParserHANDLER, PostgreSQLParserHEADER_P, PostgreSQLParserHOLD, PostgreSQLParserHOUR_P, PostgreSQLParserIDENTITY_P, PostgreSQLParserIF_P, PostgreSQLParserIMMEDIATE, PostgreSQLParserIMMUTABLE, PostgreSQLParserIMPLICIT_P, PostgreSQLParserINCLUDING, PostgreSQLParserINCREMENT, PostgreSQLParserINDEX, PostgreSQLParserINDEXES, PostgreSQLParserINHERIT, PostgreSQLParserINHERITS, PostgreSQLParserINLINE_P, PostgreSQLParserINSENSITIVE, PostgreSQLParserINSERT, PostgreSQLParserINSTEAD, PostgreSQLParserINVOKER, PostgreSQLParserISOLATION, PostgreSQLParserKEY, PostgreSQLParserLABEL, PostgreSQLParserLANGUAGE, PostgreSQLParserLARGE_P, PostgreSQLParserLAST_P, PostgreSQLParserLEAKPROOF, PostgreSQLParserLEVEL, PostgreSQLParserLISTEN, PostgreSQLParserLOAD, PostgreSQLParserLOCAL, PostgreSQLParserLOCATION, PostgreSQLParserLOCK_P, PostgreSQLParserMAPPING, PostgreSQLParserMATCH, PostgreSQLParserMATERIALIZED, PostgreSQLParserMAXVALUE, PostgreSQLParserMERGE, PostgreSQLParserMINUTE_P, PostgreSQLParserMINVALUE, PostgreSQLParserMODE, PostgreSQLParserMONTH_P, PostgreSQLParserMOVE, PostgreSQLParserNAME_P, PostgreSQLParserNAMES, PostgreSQLParserNEXT, PostgreSQLParserNO, PostgreSQLParserNOTHING, PostgreSQLParserNOTIFY, PostgreSQLParserNOWAIT, PostgreSQLParserNULLS_P, PostgreSQLParserOBJECT_P, PostgreSQLParserOF, PostgreSQLParserOFF, PostgreSQLParserOIDS, PostgreSQLParserOPERATOR, PostgreSQLParserOPTION, PostgreSQLParserOPTIONS, PostgreSQLParserOWNED, PostgreSQLParserOWNER, PostgreSQLParserPARSER, PostgreSQLParserPARTIAL, PostgreSQLParserPARTITION, PostgreSQLParserPASSING, PostgreSQLParserPASSWORD, PostgreSQLParserPLANS, PostgreSQLParserPRECEDING, PostgreSQLParserPREPARE, PostgreSQLParserPREPARED, PostgreSQLParserPRESERVE, PostgreSQLParserPRIOR, PostgreSQLParserPRIVILEGES, PostgreSQLParserPROCEDURAL, PostgreSQLParserPROCEDURE, PostgreSQLParserPROGRAM, PostgreSQLParserQUOTE, PostgreSQLParserRANGE, PostgreSQLParserREAD, PostgreSQLParserREASSIGN, PostgreSQLParserRECHECK, PostgreSQLParserRECURSIVE, PostgreSQLParserREF, PostgreSQLParserREFRESH, PostgreSQLParserREINDEX, PostgreSQLParserRELATIVE_P, PostgreSQLParserRELEASE, PostgreSQLParserRENAME, PostgreSQLParserREPEATABLE, PostgreSQLParserREPLACE, PostgreSQLParserREPLICA, PostgreSQLParserRESET, PostgreSQLParserRESTART, PostgreSQLParserRESTRICT, PostgreSQLParserRETURNS, PostgreSQLParserREVOKE, PostgreSQLParserROLE, PostgreSQLParserROLLBACK, PostgreSQLParserROWS, PostgreSQLParserRULE, PostgreSQLParserSAVEPOINT, PostgreSQLParserSCHEMA, PostgreSQLParserSCROLL, PostgreSQLParserSEARCH, PostgreSQLParserSECOND_P, PostgreSQLParserSECURITY, PostgreSQLParserSEQUENCE, PostgreSQLParserSEQUENCES, PostgreSQLParserSERIALIZABLE, PostgreSQLParserSERVER, PostgreSQLParserSESSION, PostgreSQLParserSET, PostgreSQLParserSHARE, PostgreSQLParserSHOW, PostgreSQLParserSIMPLE, PostgreSQLParserSNAPSHOT, PostgreSQLParserSTABLE, PostgreSQLParserSTANDALONE_P, PostgreSQLParserSTART, PostgreSQLParserSTATEMENT, PostgreSQLParserSTATISTICS, PostgreSQLParserSTDIN, PostgreSQLParserSTDOUT, PostgreSQLParserSTORAGE, PostgreSQLParserSTRICT_P, PostgreSQLParserSTRIP_P, PostgreSQLParserSYSID, PostgreSQLParserSYSTEM_P, PostgreSQLParserTABLES, PostgreSQLParserTABLESPACE, PostgreSQLParserTEMP, PostgreSQLParserTEMPLATE, PostgreSQLParserTEMPORARY, PostgreSQLParserTEXT_P, PostgreSQLParserTRANSACTION, PostgreSQLParserTRIGGER, PostgreSQLParserTRUNCATE, PostgreSQLParserTRUSTED, PostgreSQLParserTYPE_P, PostgreSQLParserTYPES_P, PostgreSQLParserUNBOUNDED, PostgreSQLParserUNCOMMITTED, PostgreSQLParserUNENCRYPTED, PostgreSQLParserUNKNOWN, PostgreSQLParserUNLISTEN, PostgreSQLParserUNLOGGED, PostgreSQLParserUNTIL, PostgreSQLParserUPDATE, PostgreSQLParserVACUUM, PostgreSQLParserVALID, PostgreSQLParserVALIDATE, PostgreSQLParserVALIDATOR, PostgreSQLParserVARYING, PostgreSQLParserVERSION_P, PostgreSQLParserVIEW, PostgreSQLParserVOLATILE, PostgreSQLParserWHITESPACE_P, PostgreSQLParserWITHOUT, PostgreSQLParserWORK, PostgreSQLParserWRAPPER, PostgreSQLParserWRITE, PostgreSQLParserXML_P, PostgreSQLParserYEAR_P, PostgreSQLParserYES_P, PostgreSQLParserZONE, PostgreSQLParserBETWEEN, PostgreSQLParserBIGINT, PostgreSQLParserBIT, PostgreSQLParserBOOLEAN_P, PostgreSQLParserCHAR_P, PostgreSQLParserCHARACTER, PostgreSQLParserCOALESCE, PostgreSQLParserDEC, PostgreSQLParserDECIMAL_P, PostgreSQLParserEXISTS, PostgreSQLParserEXTRACT, PostgreSQLParserFLOAT_P, PostgreSQLParserGREATEST, PostgreSQLParserINOUT, PostgreSQLParserINT_P, PostgreSQLParserINTEGER, PostgreSQLParserINTERVAL, PostgreSQLParserLEAST, PostgreSQLParserNATIONAL, PostgreSQLParserNCHAR, PostgreSQLParserNONE, PostgreSQLParserNULLIF, PostgreSQLParserNUMERIC, PostgreSQLParserOVERLAY, PostgreSQLParserPOSITION, PostgreSQLParserPRECISION, PostgreSQLParserREAL, PostgreSQLParserROW, PostgreSQLParserSETOF, PostgreSQLParserSMALLINT, PostgreSQLParserSUBSTRING, PostgreSQLParserTIME, PostgreSQLParserTIMESTAMP, PostgreSQLParserTREAT, PostgreSQLParserTRIM, PostgreSQLParserVALUES, PostgreSQLParserVARCHAR, PostgreSQLParserXMLATTRIBUTES, PostgreSQLParserXMLCOMMENT, PostgreSQLParserXMLAGG, PostgreSQLParserXML_IS_WELL_FORMED, PostgreSQLParserXML_IS_WELL_FORMED_DOCUMENT, PostgreSQLParserXML_IS_WELL_FORMED_CONTENT, PostgreSQLParserXPATH, PostgreSQLParserXPATH_EXISTS, PostgreSQLParserXMLCONCAT, PostgreSQLParserXMLELEMENT, PostgreSQLParserXMLEXISTS, PostgreSQLParserXMLFOREST, PostgreSQLParserXMLPARSE, PostgreSQLParserXMLPI, PostgreSQLParserXMLROOT, PostgreSQLParserXMLSERIALIZE, PostgreSQLParserCALL, PostgreSQLParserCURRENT_P, PostgreSQLParserATTACH, PostgreSQLParserDETACH, PostgreSQLParserEXPRESSION, PostgreSQLParserGENERATED, PostgreSQLParserLOGGED, PostgreSQLParserSTORED, PostgreSQLParserINCLUDE, PostgreSQLParserROUTINE, PostgreSQLParserTRANSFORM, PostgreSQLParserIMPORT_P, PostgreSQLParserPOLICY, PostgreSQLParserMETHOD, PostgreSQLParserREFERENCING, PostgreSQLParserNEW, PostgreSQLParserOLD, PostgreSQLParserVALUE_P, PostgreSQLParserSUBSCRIPTION, PostgreSQLParserPUBLICATION, PostgreSQLParserOUT_P, PostgreSQLParserEND_P, PostgreSQLParserROUTINES, PostgreSQLParserSCHEMAS, PostgreSQLParserPROCEDURES, PostgreSQLParserINPUT_P, PostgreSQLParserSUPPORT, PostgreSQLParserPARALLEL, PostgreSQLParserSQL_P, PostgreSQLParserDEPENDS, PostgreSQLParserOVERRIDING, PostgreSQLParserCONFLICT, PostgreSQLParserSKIP_P, PostgreSQLParserLOCKED, PostgreSQLParserTIES, PostgreSQLParserROLLUP, PostgreSQLParserCUBE, PostgreSQLParserGROUPING, PostgreSQLParserSETS, PostgreSQLParserTABLESAMPLE, PostgreSQLParserORDINALITY, PostgreSQLParserXMLTABLE, PostgreSQLParserCOLUMNS, PostgreSQLParserXMLNAMESPACES, PostgreSQLParserROWTYPE, PostgreSQLParserNORMALIZED, PostgreSQLParserWITHIN, PostgreSQLParserFILTER, PostgreSQLParserGROUPS, PostgreSQLParserOTHERS, PostgreSQLParserNFC, PostgreSQLParserNFD, PostgreSQLParserNFKC, PostgreSQLParserNFKD, PostgreSQLParserUESCAPE, PostgreSQLParserVIEWS, PostgreSQLParserNORMALIZE, PostgreSQLParserDUMP, PostgreSQLParserPRINT_STRICT_PARAMS, PostgreSQLParserVARIABLE_CONFLICT, PostgreSQLParserERROR, PostgreSQLParserUSE_VARIABLE, PostgreSQLParserUSE_COLUMN, PostgreSQLParserALIAS, PostgreSQLParserCONSTANT, PostgreSQLParserPERFORM, PostgreSQLParserGET, PostgreSQLParserDIAGNOSTICS, PostgreSQLParserSTACKED, PostgreSQLParserELSIF, PostgreSQLParserREVERSE, PostgreSQLParserSLICE, PostgreSQLParserEXIT, PostgreSQLParserRETURN, PostgreSQLParserQUERY, PostgreSQLParserRAISE, PostgreSQLParserSQLSTATE, PostgreSQLParserDEBUG, PostgreSQLParserLOG, PostgreSQLParserINFO, PostgreSQLParserNOTICE, PostgreSQLParserWARNING, PostgreSQLParserEXCEPTION, PostgreSQLParserASSERT, PostgreSQLParserLOOP, PostgreSQLParserOPEN, PostgreSQLParserABS, PostgreSQLParserCBRT, PostgreSQLParserCEIL, PostgreSQLParserCEILING, PostgreSQLParserDEGREES, PostgreSQLParserDIV, PostgreSQLParserEXP, PostgreSQLParserFACTORIAL, PostgreSQLParserFLOOR, PostgreSQLParserGCD, PostgreSQLParserLCM, PostgreSQLParserLN, PostgreSQLParserLOG10, PostgreSQLParserMIN_SCALE, PostgreSQLParserMOD, PostgreSQLParserPI, PostgreSQLParserPOWER, PostgreSQLParserRADIANS, PostgreSQLParserROUND, PostgreSQLParserSCALE, PostgreSQLParserSIGN, PostgreSQLParserSQRT, PostgreSQLParserTRIM_SCALE, PostgreSQLParserTRUNC, PostgreSQLParserWIDTH_BUCKET, PostgreSQLParserRANDOM, PostgreSQLParserSETSEED, PostgreSQLParserACOS, PostgreSQLParserACOSD, PostgreSQLParserASIN, PostgreSQLParserASIND, PostgreSQLParserATAN, PostgreSQLParserATAND, PostgreSQLParserATAN2, PostgreSQLParserATAN2D, PostgreSQLParserCOS, PostgreSQLParserCOSD, PostgreSQLParserCOT, PostgreSQLParserCOTD, PostgreSQLParserSIN, PostgreSQLParserSIND, PostgreSQLParserTAN, PostgreSQLParserTAND, PostgreSQLParserSINH, PostgreSQLParserCOSH, PostgreSQLParserTANH, PostgreSQLParserASINH, PostgreSQLParserACOSH, PostgreSQLParserATANH, PostgreSQLParserBIT_LENGTH, PostgreSQLParserCHAR_LENGTH, PostgreSQLParserCHARACTER_LENGTH, PostgreSQLParserLOWER, PostgreSQLParserOCTET_LENGTH, PostgreSQLParserUPPER, PostgreSQLParserASCII, PostgreSQLParserBTRIM, PostgreSQLParserCHR, PostgreSQLParserCONCAT, PostgreSQLParserCONCAT_WS, PostgreSQLParserFORMAT, PostgreSQLParserINITCAP, PostgreSQLParserLENGTH, PostgreSQLParserLPAD, PostgreSQLParserLTRIM, PostgreSQLParserMD5, PostgreSQLParserPARSE_IDENT, PostgreSQLParserPG_CLIENT_ENCODING, PostgreSQLParserQUOTE_IDENT, PostgreSQLParserQUOTE_LITERAL, PostgreSQLParserQUOTE_NULLABLE, PostgreSQLParserREGEXP_COUNT, PostgreSQLParserREGEXP_INSTR, PostgreSQLParserREGEXP_LIKE, PostgreSQLParserREGEXP_MATCH, PostgreSQLParserREGEXP_MATCHES, PostgreSQLParserREGEXP_REPLACE, PostgreSQLParserREGEXP_SPLIT_TO_ARRAY, PostgreSQLParserREGEXP_SPLIT_TO_TABLE, PostgreSQLParserREGEXP_SUBSTR, PostgreSQLParserREPEAT, PostgreSQLParserRPAD, PostgreSQLParserRTRIM, PostgreSQLParserSPLIT_PART, PostgreSQLParserSTARTS_WITH, PostgreSQLParserSTRING_TO_ARRAY, PostgreSQLParserSTRING_TO_TABLE, PostgreSQLParserSTRPOS, PostgreSQLParserSUBSTR, PostgreSQLParserTO_ASCII, PostgreSQLParserTO_HEX, PostgreSQLParserTRANSLATE, PostgreSQLParserUNISTR, PostgreSQLParserAGE, PostgreSQLParserCLOCK_TIMESTAMP, PostgreSQLParserDATE_BIN, PostgreSQLParserDATE_PART, PostgreSQLParserDATE_TRUNC, PostgreSQLParserISFINITE, PostgreSQLParserJUSTIFY_DAYS, PostgreSQLParserJUSTIFY_HOURS, PostgreSQLParserJUSTIFY_INTERVAL, PostgreSQLParserMAKE_DATE, PostgreSQLParserMAKE_INTERVAL, PostgreSQLParserMAKE_TIME, PostgreSQLParserMAKE_TIMESTAMP, PostgreSQLParserMAKE_TIMESTAMPTZ, PostgreSQLParserNOW, PostgreSQLParserSTATEMENT_TIMESTAMP, PostgreSQLParserTIMEOFDAY, PostgreSQLParserTRANSACTION_TIMESTAMP, PostgreSQLParserTO_TIMESTAMP, PostgreSQLParserTO_CHAR, PostgreSQLParserTO_DATE, PostgreSQLParserTO_NUMBER, PostgreSQLParserIdentifier, PostgreSQLParserQuotedIdentifier, PostgreSQLParserUnicodeQuotedIdentifier, PostgreSQLParserStringConstant, PostgreSQLParserUnicodeEscapeStringConstant, PostgreSQLParserBeginDollarStringConstant, PostgreSQLParserBinaryStringConstant, PostgreSQLParserHexadecimalStringConstant, PostgreSQLParserIntegral, PostgreSQLParserNumeric, PostgreSQLParserPLSQLVARIABLENAME, PostgreSQLParserPLSQLIDENTIFIER, PostgreSQLParserMetaCommand, PostgreSQLParserEscapeStringConstant:
			{
				p.SetState(7983)
				p.Opt_all_clause()
			}
			{
				p.SetState(7984)
				p.Into_clause()
			}
			{
				p.SetState(7985)
				p.Opt_target_list()
			}

		case PostgreSQLParserDISTINCT:
			{
				p.SetState(7987)
				p.Distinct_clause()
			}
			{
				p.SetState(7988)
				p.Target_list()
			}

		default:
			p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
			goto errorExit
		}
		{
			p.SetState(7992)
			p.Into_clause()
		}
		{
			p.SetState(7993)
			p.From_clause()
		}
		{
			p.SetState(7994)
			p.Where_clause()
		}
		{
			p.SetState(7995)
			p.Group_clause()
		}
		{
			p.SetState(7996)
			p.Having_clause()
		}
		{
			p.SetState(7997)
			p.Window_clause()
		}

	case PostgreSQLParserVALUES:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(7999)
			p.Values_clause()
		}

	case PostgreSQLParserTABLE:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(8000)
			p.Match(PostgreSQLParserTABLE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(8001)
			p.Relation_expr()
		}

	case PostgreSQLParserOPEN_PAREN:
		p.EnterOuterAlt(localctx, 4)
		{
			p.SetState(8002)
			p.Select_with_parens()
		}

	default:
		p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IWith_clauseContext is an interface to support dynamic dispatch.
type IWith_clauseContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	WITH() antlr.TerminalNode
	Cte_list() ICte_listContext
	RECURSIVE() antlr.TerminalNode

	// IsWith_clauseContext differentiates from other interfaces.
	IsWith_clauseContext()
}

type With_clauseContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyWith_clauseContext() *With_clauseContext {
	var p = new(With_clauseContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_with_clause
	return p
}

func InitEmptyWith_clauseContext(p *With_clauseContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_with_clause
}

func (*With_clauseContext) IsWith_clauseContext() {}

func NewWith_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *With_clauseContext {
	var p = new(With_clauseContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_with_clause

	return p
}

func (s *With_clauseContext) GetParser() antlr.Parser { return s.parser }

func (s *With_clauseContext) WITH() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserWITH, 0)
}

func (s *With_clauseContext) Cte_list() ICte_listContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ICte_listContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ICte_listContext)
}

func (s *With_clauseContext) RECURSIVE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserRECURSIVE, 0)
}

func (s *With_clauseContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *With_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *With_clauseContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterWith_clause(s)
	}
}

func (s *With_clauseContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitWith_clause(s)
	}
}

func (s *With_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitWith_clause(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) With_clause() (localctx IWith_clauseContext) {
	localctx = NewWith_clauseContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 972, PostgreSQLParserRULE_with_clause)
	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(8005)
		p.Match(PostgreSQLParserWITH)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	p.SetState(8007)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 425, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(8006)
			p.Match(PostgreSQLParserRECURSIVE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	} else if p.HasError() { // JIM
		goto errorExit
	}
	{
		p.SetState(8009)
		p.Cte_list()
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// ICte_listContext is an interface to support dynamic dispatch.
type ICte_listContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	AllCommon_table_expr() []ICommon_table_exprContext
	Common_table_expr(i int) ICommon_table_exprContext
	AllCOMMA() []antlr.TerminalNode
	COMMA(i int) antlr.TerminalNode

	// IsCte_listContext differentiates from other interfaces.
	IsCte_listContext()
}

type Cte_listContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyCte_listContext() *Cte_listContext {
	var p = new(Cte_listContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_cte_list
	return p
}

func InitEmptyCte_listContext(p *Cte_listContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_cte_list
}

func (*Cte_listContext) IsCte_listContext() {}

func NewCte_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Cte_listContext {
	var p = new(Cte_listContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_cte_list

	return p
}

func (s *Cte_listContext) GetParser() antlr.Parser { return s.parser }

func (s *Cte_listContext) AllCommon_table_expr() []ICommon_table_exprContext {
	children := s.GetChildren()
	len := 0
	for _, ctx := range children {
		if _, ok := ctx.(ICommon_table_exprContext); ok {
			len++
		}
	}

	tst := make([]ICommon_table_exprContext, len)
	i := 0
	for _, ctx := range children {
		if t, ok := ctx.(ICommon_table_exprContext); ok {
			tst[i] = t.(ICommon_table_exprContext)
			i++
		}
	}

	return tst
}

func (s *Cte_listContext) Common_table_expr(i int) ICommon_table_exprContext {
	var t antlr.RuleContext
	j := 0
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ICommon_table_exprContext); ok {
			if j == i {
				t = ctx.(antlr.RuleContext)
				break
			}
			j++
		}
	}

	if t == nil {
		return nil
	}

	return t.(ICommon_table_exprContext)
}

func (s *Cte_listContext) AllCOMMA() []antlr.TerminalNode {
	return s.GetTokens(PostgreSQLParserCOMMA)
}

func (s *Cte_listContext) COMMA(i int) antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCOMMA, i)
}

func (s *Cte_listContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Cte_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Cte_listContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterCte_list(s)
	}
}

func (s *Cte_listContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitCte_list(s)
	}
}

func (s *Cte_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitCte_list(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Cte_list() (localctx ICte_listContext) {
	localctx = NewCte_listContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 974, PostgreSQLParserRULE_cte_list)
	var _la int

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(8011)
		p.Common_table_expr()
	}
	p.SetState(8016)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}
	_la = p.GetTokenStream().LA(1)

	for _la == PostgreSQLParserCOMMA {
		{
			p.SetState(8012)
			p.Match(PostgreSQLParserCOMMA)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(8013)
			p.Common_table_expr()
		}

		p.SetState(8018)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}
		_la = p.GetTokenStream().LA(1)
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// ICommon_table_exprContext is an interface to support dynamic dispatch.
type ICommon_table_exprContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Name() INameContext
	Opt_name_list() IOpt_name_listContext
	AS() antlr.TerminalNode
	Opt_materialized() IOpt_materializedContext
	OPEN_PAREN() antlr.TerminalNode
	Preparablestmt() IPreparablestmtContext
	CLOSE_PAREN() antlr.TerminalNode

	// IsCommon_table_exprContext differentiates from other interfaces.
	IsCommon_table_exprContext()
}

type Common_table_exprContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyCommon_table_exprContext() *Common_table_exprContext {
	var p = new(Common_table_exprContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_common_table_expr
	return p
}

func InitEmptyCommon_table_exprContext(p *Common_table_exprContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_common_table_expr
}

func (*Common_table_exprContext) IsCommon_table_exprContext() {}

func NewCommon_table_exprContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Common_table_exprContext {
	var p = new(Common_table_exprContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_common_table_expr

	return p
}

func (s *Common_table_exprContext) GetParser() antlr.Parser { return s.parser }

func (s *Common_table_exprContext) Name() INameContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(INameContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(INameContext)
}

func (s *Common_table_exprContext) Opt_name_list() IOpt_name_listContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOpt_name_listContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOpt_name_listContext)
}

func (s *Common_table_exprContext) AS() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserAS, 0)
}

func (s *Common_table_exprContext) Opt_materialized() IOpt_materializedContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOpt_materializedContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOpt_materializedContext)
}

func (s *Common_table_exprContext) OPEN_PAREN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserOPEN_PAREN, 0)
}

func (s *Common_table_exprContext) Preparablestmt() IPreparablestmtContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IPreparablestmtContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IPreparablestmtContext)
}

func (s *Common_table_exprContext) CLOSE_PAREN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCLOSE_PAREN, 0)
}

func (s *Common_table_exprContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Common_table_exprContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Common_table_exprContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterCommon_table_expr(s)
	}
}

func (s *Common_table_exprContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitCommon_table_expr(s)
	}
}

func (s *Common_table_exprContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitCommon_table_expr(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Common_table_expr() (localctx ICommon_table_exprContext) {
	localctx = NewCommon_table_exprContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 976, PostgreSQLParserRULE_common_table_expr)
	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(8019)
		p.Name()
	}
	{
		p.SetState(8020)
		p.Opt_name_list()
	}
	{
		p.SetState(8021)
		p.Match(PostgreSQLParserAS)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(8022)
		p.Opt_materialized()
	}
	{
		p.SetState(8023)
		p.Match(PostgreSQLParserOPEN_PAREN)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(8024)
		p.Preparablestmt()
	}
	{
		p.SetState(8025)
		p.Match(PostgreSQLParserCLOSE_PAREN)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IOpt_materializedContext is an interface to support dynamic dispatch.
type IOpt_materializedContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	MATERIALIZED() antlr.TerminalNode
	NOT() antlr.TerminalNode

	// IsOpt_materializedContext differentiates from other interfaces.
	IsOpt_materializedContext()
}

type Opt_materializedContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyOpt_materializedContext() *Opt_materializedContext {
	var p = new(Opt_materializedContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opt_materialized
	return p
}

func InitEmptyOpt_materializedContext(p *Opt_materializedContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opt_materialized
}

func (*Opt_materializedContext) IsOpt_materializedContext() {}

func NewOpt_materializedContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_materializedContext {
	var p = new(Opt_materializedContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_opt_materialized

	return p
}

func (s *Opt_materializedContext) GetParser() antlr.Parser { return s.parser }

func (s *Opt_materializedContext) MATERIALIZED() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserMATERIALIZED, 0)
}

func (s *Opt_materializedContext) NOT() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserNOT, 0)
}

func (s *Opt_materializedContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Opt_materializedContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Opt_materializedContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterOpt_materialized(s)
	}
}

func (s *Opt_materializedContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitOpt_materialized(s)
	}
}

func (s *Opt_materializedContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitOpt_materialized(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Opt_materialized() (localctx IOpt_materializedContext) {
	localctx = NewOpt_materializedContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 978, PostgreSQLParserRULE_opt_materialized)
	p.SetState(8031)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetTokenStream().LA(1) {
	case PostgreSQLParserMATERIALIZED:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(8027)
			p.Match(PostgreSQLParserMATERIALIZED)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case PostgreSQLParserNOT:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(8028)
			p.Match(PostgreSQLParserNOT)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(8029)
			p.Match(PostgreSQLParserMATERIALIZED)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case PostgreSQLParserOPEN_PAREN:
		p.EnterOuterAlt(localctx, 3)

	default:
		p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IOpt_with_clauseContext is an interface to support dynamic dispatch.
type IOpt_with_clauseContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	With_clause() IWith_clauseContext

	// IsOpt_with_clauseContext differentiates from other interfaces.
	IsOpt_with_clauseContext()
}

type Opt_with_clauseContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyOpt_with_clauseContext() *Opt_with_clauseContext {
	var p = new(Opt_with_clauseContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opt_with_clause
	return p
}

func InitEmptyOpt_with_clauseContext(p *Opt_with_clauseContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opt_with_clause
}

func (*Opt_with_clauseContext) IsOpt_with_clauseContext() {}

func NewOpt_with_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_with_clauseContext {
	var p = new(Opt_with_clauseContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_opt_with_clause

	return p
}

func (s *Opt_with_clauseContext) GetParser() antlr.Parser { return s.parser }

func (s *Opt_with_clauseContext) With_clause() IWith_clauseContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IWith_clauseContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IWith_clauseContext)
}

func (s *Opt_with_clauseContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Opt_with_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Opt_with_clauseContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterOpt_with_clause(s)
	}
}

func (s *Opt_with_clauseContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitOpt_with_clause(s)
	}
}

func (s *Opt_with_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitOpt_with_clause(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Opt_with_clause() (localctx IOpt_with_clauseContext) {
	localctx = NewOpt_with_clauseContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 980, PostgreSQLParserRULE_opt_with_clause)
	p.SetState(8035)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetTokenStream().LA(1) {
	case PostgreSQLParserWITH:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(8033)
			p.With_clause()
		}

	case PostgreSQLParserDELETE_P, PostgreSQLParserINSERT, PostgreSQLParserUPDATE:
		p.EnterOuterAlt(localctx, 2)

	default:
		p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IInto_clauseContext is an interface to support dynamic dispatch.
type IInto_clauseContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	INTO() antlr.TerminalNode
	Opt_strict() IOpt_strictContext
	OpttempTableName() IOpttempTableNameContext
	Into_target() IInto_targetContext

	// IsInto_clauseContext differentiates from other interfaces.
	IsInto_clauseContext()
}

type Into_clauseContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyInto_clauseContext() *Into_clauseContext {
	var p = new(Into_clauseContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_into_clause
	return p
}

func InitEmptyInto_clauseContext(p *Into_clauseContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_into_clause
}

func (*Into_clauseContext) IsInto_clauseContext() {}

func NewInto_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Into_clauseContext {
	var p = new(Into_clauseContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_into_clause

	return p
}

func (s *Into_clauseContext) GetParser() antlr.Parser { return s.parser }

func (s *Into_clauseContext) INTO() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserINTO, 0)
}

func (s *Into_clauseContext) Opt_strict() IOpt_strictContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOpt_strictContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOpt_strictContext)
}

func (s *Into_clauseContext) OpttempTableName() IOpttempTableNameContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOpttempTableNameContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOpttempTableNameContext)
}

func (s *Into_clauseContext) Into_target() IInto_targetContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IInto_targetContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IInto_targetContext)
}

func (s *Into_clauseContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Into_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Into_clauseContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterInto_clause(s)
	}
}

func (s *Into_clauseContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitInto_clause(s)
	}
}

func (s *Into_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitInto_clause(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Into_clause() (localctx IInto_clauseContext) {
	localctx = NewInto_clauseContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 982, PostgreSQLParserRULE_into_clause)
	p.SetState(8045)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 430, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(8037)
			p.Match(PostgreSQLParserINTO)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		p.SetState(8042)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}

		switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 429, p.GetParserRuleContext()) {
		case 1:
			{
				p.SetState(8038)
				p.Opt_strict()
			}
			{
				p.SetState(8039)
				p.OpttempTableName()
			}

		case 2:
			{
				p.SetState(8041)
				p.Into_target()
			}

		case antlr.ATNInvalidAltNumber:
			goto errorExit
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)

	case antlr.ATNInvalidAltNumber:
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IOpt_strictContext is an interface to support dynamic dispatch.
type IOpt_strictContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	STRICT_P() antlr.TerminalNode

	// IsOpt_strictContext differentiates from other interfaces.
	IsOpt_strictContext()
}

type Opt_strictContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyOpt_strictContext() *Opt_strictContext {
	var p = new(Opt_strictContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opt_strict
	return p
}

func InitEmptyOpt_strictContext(p *Opt_strictContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opt_strict
}

func (*Opt_strictContext) IsOpt_strictContext() {}

func NewOpt_strictContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_strictContext {
	var p = new(Opt_strictContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_opt_strict

	return p
}

func (s *Opt_strictContext) GetParser() antlr.Parser { return s.parser }

func (s *Opt_strictContext) STRICT_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserSTRICT_P, 0)
}

func (s *Opt_strictContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Opt_strictContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Opt_strictContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterOpt_strict(s)
	}
}

func (s *Opt_strictContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitOpt_strict(s)
	}
}

func (s *Opt_strictContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitOpt_strict(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Opt_strict() (localctx IOpt_strictContext) {
	localctx = NewOpt_strictContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 984, PostgreSQLParserRULE_opt_strict)
	p.SetState(8049)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 431, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(8048)
			p.Match(PostgreSQLParserSTRICT_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case antlr.ATNInvalidAltNumber:
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IOpttempTableNameContext is an interface to support dynamic dispatch.
type IOpttempTableNameContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Opt_table() IOpt_tableContext
	Qualified_name() IQualified_nameContext
	TEMPORARY() antlr.TerminalNode
	TEMP() antlr.TerminalNode
	LOCAL() antlr.TerminalNode
	GLOBAL() antlr.TerminalNode
	UNLOGGED() antlr.TerminalNode
	TABLE() antlr.TerminalNode

	// IsOpttempTableNameContext differentiates from other interfaces.
	IsOpttempTableNameContext()
}

type OpttempTableNameContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyOpttempTableNameContext() *OpttempTableNameContext {
	var p = new(OpttempTableNameContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opttempTableName
	return p
}

func InitEmptyOpttempTableNameContext(p *OpttempTableNameContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opttempTableName
}

func (*OpttempTableNameContext) IsOpttempTableNameContext() {}

func NewOpttempTableNameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *OpttempTableNameContext {
	var p = new(OpttempTableNameContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_opttempTableName

	return p
}

func (s *OpttempTableNameContext) GetParser() antlr.Parser { return s.parser }

func (s *OpttempTableNameContext) Opt_table() IOpt_tableContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOpt_tableContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOpt_tableContext)
}

func (s *OpttempTableNameContext) Qualified_name() IQualified_nameContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IQualified_nameContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IQualified_nameContext)
}

func (s *OpttempTableNameContext) TEMPORARY() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserTEMPORARY, 0)
}

func (s *OpttempTableNameContext) TEMP() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserTEMP, 0)
}

func (s *OpttempTableNameContext) LOCAL() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserLOCAL, 0)
}

func (s *OpttempTableNameContext) GLOBAL() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserGLOBAL, 0)
}

func (s *OpttempTableNameContext) UNLOGGED() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserUNLOGGED, 0)
}

func (s *OpttempTableNameContext) TABLE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserTABLE, 0)
}

func (s *OpttempTableNameContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *OpttempTableNameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *OpttempTableNameContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterOpttempTableName(s)
	}
}

func (s *OpttempTableNameContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitOpttempTableName(s)
	}
}

func (s *OpttempTableNameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitOpttempTableName(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) OpttempTableName() (localctx IOpttempTableNameContext) {
	localctx = NewOpttempTableNameContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 986, PostgreSQLParserRULE_opttempTableName)
	var _la int

	p.SetState(8065)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 433, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		p.SetState(8052)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}
		_la = p.GetTokenStream().LA(1)

		if _la == PostgreSQLParserGLOBAL || _la == PostgreSQLParserLOCAL {
			{
				p.SetState(8051)
				_la = p.GetTokenStream().LA(1)

				if !(_la == PostgreSQLParserGLOBAL || _la == PostgreSQLParserLOCAL) {
					p.GetErrorHandler().RecoverInline(p)
				} else {
					p.GetErrorHandler().ReportMatch(p)
					p.Consume()
				}
			}

		}
		{
			p.SetState(8054)
			_la = p.GetTokenStream().LA(1)

			if !(_la == PostgreSQLParserTEMP || _la == PostgreSQLParserTEMPORARY) {
				p.GetErrorHandler().RecoverInline(p)
			} else {
				p.GetErrorHandler().ReportMatch(p)
				p.Consume()
			}
		}
		{
			p.SetState(8055)
			p.Opt_table()
		}
		{
			p.SetState(8056)
			p.Qualified_name()
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(8058)
			p.Match(PostgreSQLParserUNLOGGED)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(8059)
			p.Opt_table()
		}
		{
			p.SetState(8060)
			p.Qualified_name()
		}

	case 3:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(8062)
			p.Match(PostgreSQLParserTABLE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(8063)
			p.Qualified_name()
		}

	case 4:
		p.EnterOuterAlt(localctx, 4)
		{
			p.SetState(8064)
			p.Qualified_name()
		}

	case antlr.ATNInvalidAltNumber:
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IOpt_tableContext is an interface to support dynamic dispatch.
type IOpt_tableContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	TABLE() antlr.TerminalNode

	// IsOpt_tableContext differentiates from other interfaces.
	IsOpt_tableContext()
}

type Opt_tableContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyOpt_tableContext() *Opt_tableContext {
	var p = new(Opt_tableContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opt_table
	return p
}

func InitEmptyOpt_tableContext(p *Opt_tableContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opt_table
}

func (*Opt_tableContext) IsOpt_tableContext() {}

func NewOpt_tableContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_tableContext {
	var p = new(Opt_tableContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_opt_table

	return p
}

func (s *Opt_tableContext) GetParser() antlr.Parser { return s.parser }

func (s *Opt_tableContext) TABLE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserTABLE, 0)
}

func (s *Opt_tableContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Opt_tableContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Opt_tableContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterOpt_table(s)
	}
}

func (s *Opt_tableContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitOpt_table(s)
	}
}

func (s *Opt_tableContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitOpt_table(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Opt_table() (localctx IOpt_tableContext) {
	localctx = NewOpt_tableContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 988, PostgreSQLParserRULE_opt_table)
	p.SetState(8069)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 434, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(8067)
			p.Match(PostgreSQLParserTABLE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)

	case antlr.ATNInvalidAltNumber:
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IAll_or_distinctContext is an interface to support dynamic dispatch.
type IAll_or_distinctContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	ALL() antlr.TerminalNode
	DISTINCT() antlr.TerminalNode

	// IsAll_or_distinctContext differentiates from other interfaces.
	IsAll_or_distinctContext()
}

type All_or_distinctContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyAll_or_distinctContext() *All_or_distinctContext {
	var p = new(All_or_distinctContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_all_or_distinct
	return p
}

func InitEmptyAll_or_distinctContext(p *All_or_distinctContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_all_or_distinct
}

func (*All_or_distinctContext) IsAll_or_distinctContext() {}

func NewAll_or_distinctContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *All_or_distinctContext {
	var p = new(All_or_distinctContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_all_or_distinct

	return p
}

func (s *All_or_distinctContext) GetParser() antlr.Parser { return s.parser }

func (s *All_or_distinctContext) ALL() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserALL, 0)
}

func (s *All_or_distinctContext) DISTINCT() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserDISTINCT, 0)
}

func (s *All_or_distinctContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *All_or_distinctContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *All_or_distinctContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterAll_or_distinct(s)
	}
}

func (s *All_or_distinctContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitAll_or_distinct(s)
	}
}

func (s *All_or_distinctContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitAll_or_distinct(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) All_or_distinct() (localctx IAll_or_distinctContext) {
	localctx = NewAll_or_distinctContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 990, PostgreSQLParserRULE_all_or_distinct)
	p.SetState(8074)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetTokenStream().LA(1) {
	case PostgreSQLParserALL:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(8071)
			p.Match(PostgreSQLParserALL)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case PostgreSQLParserDISTINCT:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(8072)
			p.Match(PostgreSQLParserDISTINCT)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case PostgreSQLParserOPEN_PAREN, PostgreSQLParserSELECT, PostgreSQLParserTABLE, PostgreSQLParserVALUES:
		p.EnterOuterAlt(localctx, 3)

	default:
		p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IDistinct_clauseContext is an interface to support dynamic dispatch.
type IDistinct_clauseContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	DISTINCT() antlr.TerminalNode
	ON() antlr.TerminalNode
	OPEN_PAREN() antlr.TerminalNode
	Expr_list() IExpr_listContext
	CLOSE_PAREN() antlr.TerminalNode

	// IsDistinct_clauseContext differentiates from other interfaces.
	IsDistinct_clauseContext()
}

type Distinct_clauseContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyDistinct_clauseContext() *Distinct_clauseContext {
	var p = new(Distinct_clauseContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_distinct_clause
	return p
}

func InitEmptyDistinct_clauseContext(p *Distinct_clauseContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_distinct_clause
}

func (*Distinct_clauseContext) IsDistinct_clauseContext() {}

func NewDistinct_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Distinct_clauseContext {
	var p = new(Distinct_clauseContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_distinct_clause

	return p
}

func (s *Distinct_clauseContext) GetParser() antlr.Parser { return s.parser }

func (s *Distinct_clauseContext) DISTINCT() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserDISTINCT, 0)
}

func (s *Distinct_clauseContext) ON() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserON, 0)
}

func (s *Distinct_clauseContext) OPEN_PAREN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserOPEN_PAREN, 0)
}

func (s *Distinct_clauseContext) Expr_list() IExpr_listContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IExpr_listContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IExpr_listContext)
}

func (s *Distinct_clauseContext) CLOSE_PAREN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCLOSE_PAREN, 0)
}

func (s *Distinct_clauseContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Distinct_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Distinct_clauseContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterDistinct_clause(s)
	}
}

func (s *Distinct_clauseContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitDistinct_clause(s)
	}
}

func (s *Distinct_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitDistinct_clause(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Distinct_clause() (localctx IDistinct_clauseContext) {
	localctx = NewDistinct_clauseContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 992, PostgreSQLParserRULE_distinct_clause)
	var _la int

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(8076)
		p.Match(PostgreSQLParserDISTINCT)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	p.SetState(8082)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}
	_la = p.GetTokenStream().LA(1)

	if _la == PostgreSQLParserON {
		{
			p.SetState(8077)
			p.Match(PostgreSQLParserON)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(8078)
			p.Match(PostgreSQLParserOPEN_PAREN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(8079)
			p.Expr_list()
		}
		{
			p.SetState(8080)
			p.Match(PostgreSQLParserCLOSE_PAREN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IOpt_all_clauseContext is an interface to support dynamic dispatch.
type IOpt_all_clauseContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	ALL() antlr.TerminalNode

	// IsOpt_all_clauseContext differentiates from other interfaces.
	IsOpt_all_clauseContext()
}

type Opt_all_clauseContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyOpt_all_clauseContext() *Opt_all_clauseContext {
	var p = new(Opt_all_clauseContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opt_all_clause
	return p
}

func InitEmptyOpt_all_clauseContext(p *Opt_all_clauseContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opt_all_clause
}

func (*Opt_all_clauseContext) IsOpt_all_clauseContext() {}

func NewOpt_all_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_all_clauseContext {
	var p = new(Opt_all_clauseContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_opt_all_clause

	return p
}

func (s *Opt_all_clauseContext) GetParser() antlr.Parser { return s.parser }

func (s *Opt_all_clauseContext) ALL() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserALL, 0)
}

func (s *Opt_all_clauseContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Opt_all_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Opt_all_clauseContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterOpt_all_clause(s)
	}
}

func (s *Opt_all_clauseContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitOpt_all_clause(s)
	}
}

func (s *Opt_all_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitOpt_all_clause(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Opt_all_clause() (localctx IOpt_all_clauseContext) {
	localctx = NewOpt_all_clauseContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 994, PostgreSQLParserRULE_opt_all_clause)
	p.SetState(8086)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetTokenStream().LA(1) {
	case PostgreSQLParserALL:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(8084)
			p.Match(PostgreSQLParserALL)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case PostgreSQLParserEOF, PostgreSQLParserOPEN_PAREN, PostgreSQLParserCLOSE_PAREN, PostgreSQLParserSEMI, PostgreSQLParserSTAR, PostgreSQLParserPLUS, PostgreSQLParserMINUS, PostgreSQLParserPARAM, PostgreSQLParserOperator, PostgreSQLParserANALYSE, PostgreSQLParserANALYZE, PostgreSQLParserAND, PostgreSQLParserARRAY, PostgreSQLParserCASE, PostgreSQLParserCAST, PostgreSQLParserCOLLATE, PostgreSQLParserCOLUMN, PostgreSQLParserCONSTRAINT, PostgreSQLParserCREATE, PostgreSQLParserCURRENT_CATALOG, PostgreSQLParserCURRENT_DATE, PostgreSQLParserCURRENT_ROLE, PostgreSQLParserCURRENT_TIME, PostgreSQLParserCURRENT_TIMESTAMP, PostgreSQLParserCURRENT_USER, PostgreSQLParserDEFAULT, PostgreSQLParserDO, PostgreSQLParserEXCEPT, PostgreSQLParserFALSE_P, PostgreSQLParserFETCH, PostgreSQLParserFOR, PostgreSQLParserFROM, PostgreSQLParserGRANT, PostgreSQLParserGROUP_P, PostgreSQLParserHAVING, PostgreSQLParserINTERSECT, PostgreSQLParserINTO, PostgreSQLParserLIMIT, PostgreSQLParserLOCALTIME, PostgreSQLParserLOCALTIMESTAMP, PostgreSQLParserNOT, PostgreSQLParserNULL_P, PostgreSQLParserOFFSET, PostgreSQLParserON, PostgreSQLParserORDER, PostgreSQLParserRETURNING, PostgreSQLParserSELECT, PostgreSQLParserSESSION_USER, PostgreSQLParserTABLE, PostgreSQLParserTRUE_P, PostgreSQLParserUNION, PostgreSQLParserUNIQUE, PostgreSQLParserUSER, PostgreSQLParserWHERE, PostgreSQLParserWINDOW, PostgreSQLParserWITH, PostgreSQLParserAUTHORIZATION, PostgreSQLParserBINARY, PostgreSQLParserCOLLATION, PostgreSQLParserCONCURRENTLY, PostgreSQLParserCROSS, PostgreSQLParserCURRENT_SCHEMA, PostgreSQLParserFREEZE, PostgreSQLParserFULL, PostgreSQLParserILIKE, PostgreSQLParserINNER_P, PostgreSQLParserIS, PostgreSQLParserISNULL, PostgreSQLParserJOIN, PostgreSQLParserLEFT, PostgreSQLParserLIKE, PostgreSQLParserNATURAL, PostgreSQLParserNOTNULL, PostgreSQLParserOUTER_P, PostgreSQLParserOVER, PostgreSQLParserOVERLAPS, PostgreSQLParserRIGHT, PostgreSQLParserSIMILAR, PostgreSQLParserVERBOSE, PostgreSQLParserABORT_P, PostgreSQLParserABSOLUTE_P, PostgreSQLParserACCESS, PostgreSQLParserACTION, PostgreSQLParserADD_P, PostgreSQLParserADMIN, PostgreSQLParserAFTER, PostgreSQLParserAGGREGATE, PostgreSQLParserALSO, PostgreSQLParserALTER, PostgreSQLParserALWAYS, PostgreSQLParserASSERTION, PostgreSQLParserASSIGNMENT, PostgreSQLParserAT, PostgreSQLParserATTRIBUTE, PostgreSQLParserBACKWARD, PostgreSQLParserBEFORE, PostgreSQLParserBEGIN_P, PostgreSQLParserBY, PostgreSQLParserCACHE, PostgreSQLParserCALLED, PostgreSQLParserCASCADE, PostgreSQLParserCASCADED, PostgreSQLParserCATALOG, PostgreSQLParserCHAIN, PostgreSQLParserCHARACTERISTICS, PostgreSQLParserCHECKPOINT, PostgreSQLParserCLASS, PostgreSQLParserCLOSE, PostgreSQLParserCLUSTER, PostgreSQLParserCOMMENT, PostgreSQLParserCOMMENTS, PostgreSQLParserCOMMIT, PostgreSQLParserCOMMITTED, PostgreSQLParserCONFIGURATION, PostgreSQLParserCONNECTION, PostgreSQLParserCONSTRAINTS, PostgreSQLParserCONTENT_P, PostgreSQLParserCONTINUE_P, PostgreSQLParserCONVERSION_P, PostgreSQLParserCOPY, PostgreSQLParserCOST, PostgreSQLParserCSV, PostgreSQLParserCURSOR, PostgreSQLParserCYCLE, PostgreSQLParserDATA_P, PostgreSQLParserDATABASE, PostgreSQLParserDAY_P, PostgreSQLParserDEALLOCATE, PostgreSQLParserDECLARE, PostgreSQLParserDEFAULTS, PostgreSQLParserDEFERRED, PostgreSQLParserDEFINER, PostgreSQLParserDELETE_P, PostgreSQLParserDELIMITER, PostgreSQLParserDELIMITERS, PostgreSQLParserDICTIONARY, PostgreSQLParserDISABLE_P, PostgreSQLParserDISCARD, PostgreSQLParserDOCUMENT_P, PostgreSQLParserDOMAIN_P, PostgreSQLParserDOUBLE_P, PostgreSQLParserDROP, PostgreSQLParserEACH, PostgreSQLParserENABLE_P, PostgreSQLParserENCODING, PostgreSQLParserENCRYPTED, PostgreSQLParserENUM_P, PostgreSQLParserESCAPE, PostgreSQLParserEVENT, PostgreSQLParserEXCLUDE, PostgreSQLParserEXCLUDING, PostgreSQLParserEXCLUSIVE, PostgreSQLParserEXECUTE, PostgreSQLParserEXPLAIN, PostgreSQLParserEXTENSION, PostgreSQLParserEXTERNAL, PostgreSQLParserFAMILY, PostgreSQLParserFIRST_P, PostgreSQLParserFOLLOWING, PostgreSQLParserFORCE, PostgreSQLParserFORWARD, PostgreSQLParserFUNCTION, PostgreSQLParserFUNCTIONS, PostgreSQLParserGLOBAL, PostgreSQLParserGRANTED, PostgreSQLParserHANDLER, PostgreSQLParserHEADER_P, PostgreSQLParserHOLD, PostgreSQLParserHOUR_P, PostgreSQLParserIDENTITY_P, PostgreSQLParserIF_P, PostgreSQLParserIMMEDIATE, PostgreSQLParserIMMUTABLE, PostgreSQLParserIMPLICIT_P, PostgreSQLParserINCLUDING, PostgreSQLParserINCREMENT, PostgreSQLParserINDEX, PostgreSQLParserINDEXES, PostgreSQLParserINHERIT, PostgreSQLParserINHERITS, PostgreSQLParserINLINE_P, PostgreSQLParserINSENSITIVE, PostgreSQLParserINSERT, PostgreSQLParserINSTEAD, PostgreSQLParserINVOKER, PostgreSQLParserISOLATION, PostgreSQLParserKEY, PostgreSQLParserLABEL, PostgreSQLParserLANGUAGE, PostgreSQLParserLARGE_P, PostgreSQLParserLAST_P, PostgreSQLParserLEAKPROOF, PostgreSQLParserLEVEL, PostgreSQLParserLISTEN, PostgreSQLParserLOAD, PostgreSQLParserLOCAL, PostgreSQLParserLOCATION, PostgreSQLParserLOCK_P, PostgreSQLParserMAPPING, PostgreSQLParserMATCH, PostgreSQLParserMATERIALIZED, PostgreSQLParserMAXVALUE, PostgreSQLParserMERGE, PostgreSQLParserMINUTE_P, PostgreSQLParserMINVALUE, PostgreSQLParserMODE, PostgreSQLParserMONTH_P, PostgreSQLParserMOVE, PostgreSQLParserNAME_P, PostgreSQLParserNAMES, PostgreSQLParserNEXT, PostgreSQLParserNO, PostgreSQLParserNOTHING, PostgreSQLParserNOTIFY, PostgreSQLParserNOWAIT, PostgreSQLParserNULLS_P, PostgreSQLParserOBJECT_P, PostgreSQLParserOF, PostgreSQLParserOFF, PostgreSQLParserOIDS, PostgreSQLParserOPERATOR, PostgreSQLParserOPTION, PostgreSQLParserOPTIONS, PostgreSQLParserOWNED, PostgreSQLParserOWNER, PostgreSQLParserPARSER, PostgreSQLParserPARTIAL, PostgreSQLParserPARTITION, PostgreSQLParserPASSING, PostgreSQLParserPASSWORD, PostgreSQLParserPLANS, PostgreSQLParserPRECEDING, PostgreSQLParserPREPARE, PostgreSQLParserPREPARED, PostgreSQLParserPRESERVE, PostgreSQLParserPRIOR, PostgreSQLParserPRIVILEGES, PostgreSQLParserPROCEDURAL, PostgreSQLParserPROCEDURE, PostgreSQLParserPROGRAM, PostgreSQLParserQUOTE, PostgreSQLParserRANGE, PostgreSQLParserREAD, PostgreSQLParserREASSIGN, PostgreSQLParserRECHECK, PostgreSQLParserRECURSIVE, PostgreSQLParserREF, PostgreSQLParserREFRESH, PostgreSQLParserREINDEX, PostgreSQLParserRELATIVE_P, PostgreSQLParserRELEASE, PostgreSQLParserRENAME, PostgreSQLParserREPEATABLE, PostgreSQLParserREPLACE, PostgreSQLParserREPLICA, PostgreSQLParserRESET, PostgreSQLParserRESTART, PostgreSQLParserRESTRICT, PostgreSQLParserRETURNS, PostgreSQLParserREVOKE, PostgreSQLParserROLE, PostgreSQLParserROLLBACK, PostgreSQLParserROWS, PostgreSQLParserRULE, PostgreSQLParserSAVEPOINT, PostgreSQLParserSCHEMA, PostgreSQLParserSCROLL, PostgreSQLParserSEARCH, PostgreSQLParserSECOND_P, PostgreSQLParserSECURITY, PostgreSQLParserSEQUENCE, PostgreSQLParserSEQUENCES, PostgreSQLParserSERIALIZABLE, PostgreSQLParserSERVER, PostgreSQLParserSESSION, PostgreSQLParserSET, PostgreSQLParserSHARE, PostgreSQLParserSHOW, PostgreSQLParserSIMPLE, PostgreSQLParserSNAPSHOT, PostgreSQLParserSTABLE, PostgreSQLParserSTANDALONE_P, PostgreSQLParserSTART, PostgreSQLParserSTATEMENT, PostgreSQLParserSTATISTICS, PostgreSQLParserSTDIN, PostgreSQLParserSTDOUT, PostgreSQLParserSTORAGE, PostgreSQLParserSTRICT_P, PostgreSQLParserSTRIP_P, PostgreSQLParserSYSID, PostgreSQLParserSYSTEM_P, PostgreSQLParserTABLES, PostgreSQLParserTABLESPACE, PostgreSQLParserTEMP, PostgreSQLParserTEMPLATE, PostgreSQLParserTEMPORARY, PostgreSQLParserTEXT_P, PostgreSQLParserTRANSACTION, PostgreSQLParserTRIGGER, PostgreSQLParserTRUNCATE, PostgreSQLParserTRUSTED, PostgreSQLParserTYPE_P, PostgreSQLParserTYPES_P, PostgreSQLParserUNBOUNDED, PostgreSQLParserUNCOMMITTED, PostgreSQLParserUNENCRYPTED, PostgreSQLParserUNKNOWN, PostgreSQLParserUNLISTEN, PostgreSQLParserUNLOGGED, PostgreSQLParserUNTIL, PostgreSQLParserUPDATE, PostgreSQLParserVACUUM, PostgreSQLParserVALID, PostgreSQLParserVALIDATE, PostgreSQLParserVALIDATOR, PostgreSQLParserVARYING, PostgreSQLParserVERSION_P, PostgreSQLParserVIEW, PostgreSQLParserVOLATILE, PostgreSQLParserWHITESPACE_P, PostgreSQLParserWITHOUT, PostgreSQLParserWORK, PostgreSQLParserWRAPPER, PostgreSQLParserWRITE, PostgreSQLParserXML_P, PostgreSQLParserYEAR_P, PostgreSQLParserYES_P, PostgreSQLParserZONE, PostgreSQLParserBETWEEN, PostgreSQLParserBIGINT, PostgreSQLParserBIT, PostgreSQLParserBOOLEAN_P, PostgreSQLParserCHAR_P, PostgreSQLParserCHARACTER, PostgreSQLParserCOALESCE, PostgreSQLParserDEC, PostgreSQLParserDECIMAL_P, PostgreSQLParserEXISTS, PostgreSQLParserEXTRACT, PostgreSQLParserFLOAT_P, PostgreSQLParserGREATEST, PostgreSQLParserINOUT, PostgreSQLParserINT_P, PostgreSQLParserINTEGER, PostgreSQLParserINTERVAL, PostgreSQLParserLEAST, PostgreSQLParserNATIONAL, PostgreSQLParserNCHAR, PostgreSQLParserNONE, PostgreSQLParserNULLIF, PostgreSQLParserNUMERIC, PostgreSQLParserOVERLAY, PostgreSQLParserPOSITION, PostgreSQLParserPRECISION, PostgreSQLParserREAL, PostgreSQLParserROW, PostgreSQLParserSETOF, PostgreSQLParserSMALLINT, PostgreSQLParserSUBSTRING, PostgreSQLParserTIME, PostgreSQLParserTIMESTAMP, PostgreSQLParserTREAT, PostgreSQLParserTRIM, PostgreSQLParserVALUES, PostgreSQLParserVARCHAR, PostgreSQLParserXMLATTRIBUTES, PostgreSQLParserXMLCOMMENT, PostgreSQLParserXMLAGG, PostgreSQLParserXML_IS_WELL_FORMED, PostgreSQLParserXML_IS_WELL_FORMED_DOCUMENT, PostgreSQLParserXML_IS_WELL_FORMED_CONTENT, PostgreSQLParserXPATH, PostgreSQLParserXPATH_EXISTS, PostgreSQLParserXMLCONCAT, PostgreSQLParserXMLELEMENT, PostgreSQLParserXMLEXISTS, PostgreSQLParserXMLFOREST, PostgreSQLParserXMLPARSE, PostgreSQLParserXMLPI, PostgreSQLParserXMLROOT, PostgreSQLParserXMLSERIALIZE, PostgreSQLParserCALL, PostgreSQLParserCURRENT_P, PostgreSQLParserATTACH, PostgreSQLParserDETACH, PostgreSQLParserEXPRESSION, PostgreSQLParserGENERATED, PostgreSQLParserLOGGED, PostgreSQLParserSTORED, PostgreSQLParserINCLUDE, PostgreSQLParserROUTINE, PostgreSQLParserTRANSFORM, PostgreSQLParserIMPORT_P, PostgreSQLParserPOLICY, PostgreSQLParserMETHOD, PostgreSQLParserREFERENCING, PostgreSQLParserNEW, PostgreSQLParserOLD, PostgreSQLParserVALUE_P, PostgreSQLParserSUBSCRIPTION, PostgreSQLParserPUBLICATION, PostgreSQLParserOUT_P, PostgreSQLParserEND_P, PostgreSQLParserROUTINES, PostgreSQLParserSCHEMAS, PostgreSQLParserPROCEDURES, PostgreSQLParserINPUT_P, PostgreSQLParserSUPPORT, PostgreSQLParserPARALLEL, PostgreSQLParserSQL_P, PostgreSQLParserDEPENDS, PostgreSQLParserOVERRIDING, PostgreSQLParserCONFLICT, PostgreSQLParserSKIP_P, PostgreSQLParserLOCKED, PostgreSQLParserTIES, PostgreSQLParserROLLUP, PostgreSQLParserCUBE, PostgreSQLParserGROUPING, PostgreSQLParserSETS, PostgreSQLParserTABLESAMPLE, PostgreSQLParserORDINALITY, PostgreSQLParserXMLTABLE, PostgreSQLParserCOLUMNS, PostgreSQLParserXMLNAMESPACES, PostgreSQLParserROWTYPE, PostgreSQLParserNORMALIZED, PostgreSQLParserWITHIN, PostgreSQLParserFILTER, PostgreSQLParserGROUPS, PostgreSQLParserOTHERS, PostgreSQLParserNFC, PostgreSQLParserNFD, PostgreSQLParserNFKC, PostgreSQLParserNFKD, PostgreSQLParserUESCAPE, PostgreSQLParserVIEWS, PostgreSQLParserNORMALIZE, PostgreSQLParserDUMP, PostgreSQLParserPRINT_STRICT_PARAMS, PostgreSQLParserVARIABLE_CONFLICT, PostgreSQLParserERROR, PostgreSQLParserUSE_VARIABLE, PostgreSQLParserUSE_COLUMN, PostgreSQLParserALIAS, PostgreSQLParserCONSTANT, PostgreSQLParserPERFORM, PostgreSQLParserGET, PostgreSQLParserDIAGNOSTICS, PostgreSQLParserSTACKED, PostgreSQLParserELSIF, PostgreSQLParserREVERSE, PostgreSQLParserSLICE, PostgreSQLParserEXIT, PostgreSQLParserRETURN, PostgreSQLParserQUERY, PostgreSQLParserRAISE, PostgreSQLParserSQLSTATE, PostgreSQLParserDEBUG, PostgreSQLParserLOG, PostgreSQLParserINFO, PostgreSQLParserNOTICE, PostgreSQLParserWARNING, PostgreSQLParserEXCEPTION, PostgreSQLParserASSERT, PostgreSQLParserLOOP, PostgreSQLParserOPEN, PostgreSQLParserABS, PostgreSQLParserCBRT, PostgreSQLParserCEIL, PostgreSQLParserCEILING, PostgreSQLParserDEGREES, PostgreSQLParserDIV, PostgreSQLParserEXP, PostgreSQLParserFACTORIAL, PostgreSQLParserFLOOR, PostgreSQLParserGCD, PostgreSQLParserLCM, PostgreSQLParserLN, PostgreSQLParserLOG10, PostgreSQLParserMIN_SCALE, PostgreSQLParserMOD, PostgreSQLParserPI, PostgreSQLParserPOWER, PostgreSQLParserRADIANS, PostgreSQLParserROUND, PostgreSQLParserSCALE, PostgreSQLParserSIGN, PostgreSQLParserSQRT, PostgreSQLParserTRIM_SCALE, PostgreSQLParserTRUNC, PostgreSQLParserWIDTH_BUCKET, PostgreSQLParserRANDOM, PostgreSQLParserSETSEED, PostgreSQLParserACOS, PostgreSQLParserACOSD, PostgreSQLParserASIN, PostgreSQLParserASIND, PostgreSQLParserATAN, PostgreSQLParserATAND, PostgreSQLParserATAN2, PostgreSQLParserATAN2D, PostgreSQLParserCOS, PostgreSQLParserCOSD, PostgreSQLParserCOT, PostgreSQLParserCOTD, PostgreSQLParserSIN, PostgreSQLParserSIND, PostgreSQLParserTAN, PostgreSQLParserTAND, PostgreSQLParserSINH, PostgreSQLParserCOSH, PostgreSQLParserTANH, PostgreSQLParserASINH, PostgreSQLParserACOSH, PostgreSQLParserATANH, PostgreSQLParserBIT_LENGTH, PostgreSQLParserCHAR_LENGTH, PostgreSQLParserCHARACTER_LENGTH, PostgreSQLParserLOWER, PostgreSQLParserOCTET_LENGTH, PostgreSQLParserUPPER, PostgreSQLParserASCII, PostgreSQLParserBTRIM, PostgreSQLParserCHR, PostgreSQLParserCONCAT, PostgreSQLParserCONCAT_WS, PostgreSQLParserFORMAT, PostgreSQLParserINITCAP, PostgreSQLParserLENGTH, PostgreSQLParserLPAD, PostgreSQLParserLTRIM, PostgreSQLParserMD5, PostgreSQLParserPARSE_IDENT, PostgreSQLParserPG_CLIENT_ENCODING, PostgreSQLParserQUOTE_IDENT, PostgreSQLParserQUOTE_LITERAL, PostgreSQLParserQUOTE_NULLABLE, PostgreSQLParserREGEXP_COUNT, PostgreSQLParserREGEXP_INSTR, PostgreSQLParserREGEXP_LIKE, PostgreSQLParserREGEXP_MATCH, PostgreSQLParserREGEXP_MATCHES, PostgreSQLParserREGEXP_REPLACE, PostgreSQLParserREGEXP_SPLIT_TO_ARRAY, PostgreSQLParserREGEXP_SPLIT_TO_TABLE, PostgreSQLParserREGEXP_SUBSTR, PostgreSQLParserREPEAT, PostgreSQLParserRPAD, PostgreSQLParserRTRIM, PostgreSQLParserSPLIT_PART, PostgreSQLParserSTARTS_WITH, PostgreSQLParserSTRING_TO_ARRAY, PostgreSQLParserSTRING_TO_TABLE, PostgreSQLParserSTRPOS, PostgreSQLParserSUBSTR, PostgreSQLParserTO_ASCII, PostgreSQLParserTO_HEX, PostgreSQLParserTRANSLATE, PostgreSQLParserUNISTR, PostgreSQLParserAGE, PostgreSQLParserCLOCK_TIMESTAMP, PostgreSQLParserDATE_BIN, PostgreSQLParserDATE_PART, PostgreSQLParserDATE_TRUNC, PostgreSQLParserISFINITE, PostgreSQLParserJUSTIFY_DAYS, PostgreSQLParserJUSTIFY_HOURS, PostgreSQLParserJUSTIFY_INTERVAL, PostgreSQLParserMAKE_DATE, PostgreSQLParserMAKE_INTERVAL, PostgreSQLParserMAKE_TIME, PostgreSQLParserMAKE_TIMESTAMP, PostgreSQLParserMAKE_TIMESTAMPTZ, PostgreSQLParserNOW, PostgreSQLParserSTATEMENT_TIMESTAMP, PostgreSQLParserTIMEOFDAY, PostgreSQLParserTRANSACTION_TIMESTAMP, PostgreSQLParserTO_TIMESTAMP, PostgreSQLParserTO_CHAR, PostgreSQLParserTO_DATE, PostgreSQLParserTO_NUMBER, PostgreSQLParserIdentifier, PostgreSQLParserQuotedIdentifier, PostgreSQLParserUnicodeQuotedIdentifier, PostgreSQLParserStringConstant, PostgreSQLParserUnicodeEscapeStringConstant, PostgreSQLParserBeginDollarStringConstant, PostgreSQLParserBinaryStringConstant, PostgreSQLParserHexadecimalStringConstant, PostgreSQLParserIntegral, PostgreSQLParserNumeric, PostgreSQLParserPLSQLVARIABLENAME, PostgreSQLParserPLSQLIDENTIFIER, PostgreSQLParserMetaCommand, PostgreSQLParserEscapeStringConstant:
		p.EnterOuterAlt(localctx, 2)

	default:
		p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IOpt_sort_clauseContext is an interface to support dynamic dispatch.
type IOpt_sort_clauseContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Sort_clause() ISort_clauseContext

	// IsOpt_sort_clauseContext differentiates from other interfaces.
	IsOpt_sort_clauseContext()
}

type Opt_sort_clauseContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyOpt_sort_clauseContext() *Opt_sort_clauseContext {
	var p = new(Opt_sort_clauseContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opt_sort_clause
	return p
}

func InitEmptyOpt_sort_clauseContext(p *Opt_sort_clauseContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opt_sort_clause
}

func (*Opt_sort_clauseContext) IsOpt_sort_clauseContext() {}

func NewOpt_sort_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_sort_clauseContext {
	var p = new(Opt_sort_clauseContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_opt_sort_clause

	return p
}

func (s *Opt_sort_clauseContext) GetParser() antlr.Parser { return s.parser }

func (s *Opt_sort_clauseContext) Sort_clause() ISort_clauseContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ISort_clauseContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ISort_clauseContext)
}

func (s *Opt_sort_clauseContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Opt_sort_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Opt_sort_clauseContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterOpt_sort_clause(s)
	}
}

func (s *Opt_sort_clauseContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitOpt_sort_clause(s)
	}
}

func (s *Opt_sort_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitOpt_sort_clause(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Opt_sort_clause() (localctx IOpt_sort_clauseContext) {
	localctx = NewOpt_sort_clauseContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 996, PostgreSQLParserRULE_opt_sort_clause)
	p.SetState(8090)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetTokenStream().LA(1) {
	case PostgreSQLParserORDER:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(8088)
			p.Sort_clause()
		}

	case PostgreSQLParserEOF, PostgreSQLParserOPEN_PAREN, PostgreSQLParserCLOSE_PAREN, PostgreSQLParserSEMI, PostgreSQLParserANALYSE, PostgreSQLParserANALYZE, PostgreSQLParserCREATE, PostgreSQLParserDO, PostgreSQLParserFETCH, PostgreSQLParserFOR, PostgreSQLParserGRANT, PostgreSQLParserINTO, PostgreSQLParserLIMIT, PostgreSQLParserOFFSET, PostgreSQLParserON, PostgreSQLParserRETURNING, PostgreSQLParserSELECT, PostgreSQLParserTABLE, PostgreSQLParserWITH, PostgreSQLParserABORT_P, PostgreSQLParserALTER, PostgreSQLParserBEGIN_P, PostgreSQLParserCHECKPOINT, PostgreSQLParserCLOSE, PostgreSQLParserCLUSTER, PostgreSQLParserCOMMENT, PostgreSQLParserCOMMIT, PostgreSQLParserCOPY, PostgreSQLParserDEALLOCATE, PostgreSQLParserDECLARE, PostgreSQLParserDELETE_P, PostgreSQLParserDISCARD, PostgreSQLParserDROP, PostgreSQLParserEXECUTE, PostgreSQLParserEXPLAIN, PostgreSQLParserINSERT, PostgreSQLParserLISTEN, PostgreSQLParserLOAD, PostgreSQLParserLOCK_P, PostgreSQLParserMERGE, PostgreSQLParserMOVE, PostgreSQLParserNOTIFY, PostgreSQLParserPREPARE, PostgreSQLParserRANGE, PostgreSQLParserREASSIGN, PostgreSQLParserREFRESH, PostgreSQLParserREINDEX, PostgreSQLParserRELEASE, PostgreSQLParserRESET, PostgreSQLParserREVOKE, PostgreSQLParserROLLBACK, PostgreSQLParserROWS, PostgreSQLParserSAVEPOINT, PostgreSQLParserSECURITY, PostgreSQLParserSET, PostgreSQLParserSHOW, PostgreSQLParserSTART, PostgreSQLParserTRUNCATE, PostgreSQLParserUNLISTEN, PostgreSQLParserUPDATE, PostgreSQLParserVACUUM, PostgreSQLParserVALUES, PostgreSQLParserCALL, PostgreSQLParserIMPORT_P, PostgreSQLParserEND_P, PostgreSQLParserGROUPS, PostgreSQLParserLOOP, PostgreSQLParserMetaCommand:
		p.EnterOuterAlt(localctx, 2)

	default:
		p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// ISort_clauseContext is an interface to support dynamic dispatch.
type ISort_clauseContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	ORDER() antlr.TerminalNode
	BY() antlr.TerminalNode
	Sortby_list() ISortby_listContext

	// IsSort_clauseContext differentiates from other interfaces.
	IsSort_clauseContext()
}

type Sort_clauseContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptySort_clauseContext() *Sort_clauseContext {
	var p = new(Sort_clauseContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_sort_clause
	return p
}

func InitEmptySort_clauseContext(p *Sort_clauseContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_sort_clause
}

func (*Sort_clauseContext) IsSort_clauseContext() {}

func NewSort_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Sort_clauseContext {
	var p = new(Sort_clauseContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_sort_clause

	return p
}

func (s *Sort_clauseContext) GetParser() antlr.Parser { return s.parser }

func (s *Sort_clauseContext) ORDER() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserORDER, 0)
}

func (s *Sort_clauseContext) BY() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserBY, 0)
}

func (s *Sort_clauseContext) Sortby_list() ISortby_listContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ISortby_listContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ISortby_listContext)
}

func (s *Sort_clauseContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Sort_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Sort_clauseContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterSort_clause(s)
	}
}

func (s *Sort_clauseContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitSort_clause(s)
	}
}

func (s *Sort_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitSort_clause(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Sort_clause() (localctx ISort_clauseContext) {
	localctx = NewSort_clauseContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 998, PostgreSQLParserRULE_sort_clause)
	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(8092)
		p.Match(PostgreSQLParserORDER)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(8093)
		p.Match(PostgreSQLParserBY)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(8094)
		p.Sortby_list()
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// ISortby_listContext is an interface to support dynamic dispatch.
type ISortby_listContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	AllSortby() []ISortbyContext
	Sortby(i int) ISortbyContext
	AllCOMMA() []antlr.TerminalNode
	COMMA(i int) antlr.TerminalNode

	// IsSortby_listContext differentiates from other interfaces.
	IsSortby_listContext()
}

type Sortby_listContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptySortby_listContext() *Sortby_listContext {
	var p = new(Sortby_listContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_sortby_list
	return p
}

func InitEmptySortby_listContext(p *Sortby_listContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_sortby_list
}

func (*Sortby_listContext) IsSortby_listContext() {}

func NewSortby_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Sortby_listContext {
	var p = new(Sortby_listContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_sortby_list

	return p
}

func (s *Sortby_listContext) GetParser() antlr.Parser { return s.parser }

func (s *Sortby_listContext) AllSortby() []ISortbyContext {
	children := s.GetChildren()
	len := 0
	for _, ctx := range children {
		if _, ok := ctx.(ISortbyContext); ok {
			len++
		}
	}

	tst := make([]ISortbyContext, len)
	i := 0
	for _, ctx := range children {
		if t, ok := ctx.(ISortbyContext); ok {
			tst[i] = t.(ISortbyContext)
			i++
		}
	}

	return tst
}

func (s *Sortby_listContext) Sortby(i int) ISortbyContext {
	var t antlr.RuleContext
	j := 0
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ISortbyContext); ok {
			if j == i {
				t = ctx.(antlr.RuleContext)
				break
			}
			j++
		}
	}

	if t == nil {
		return nil
	}

	return t.(ISortbyContext)
}

func (s *Sortby_listContext) AllCOMMA() []antlr.TerminalNode {
	return s.GetTokens(PostgreSQLParserCOMMA)
}

func (s *Sortby_listContext) COMMA(i int) antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCOMMA, i)
}

func (s *Sortby_listContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Sortby_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Sortby_listContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterSortby_list(s)
	}
}

func (s *Sortby_listContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitSortby_list(s)
	}
}

func (s *Sortby_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitSortby_list(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Sortby_list() (localctx ISortby_listContext) {
	localctx = NewSortby_listContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1000, PostgreSQLParserRULE_sortby_list)
	var _la int

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(8096)
		p.Sortby()
	}
	p.SetState(8101)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}
	_la = p.GetTokenStream().LA(1)

	for _la == PostgreSQLParserCOMMA {
		{
			p.SetState(8097)
			p.Match(PostgreSQLParserCOMMA)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(8098)
			p.Sortby()
		}

		p.SetState(8103)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}
		_la = p.GetTokenStream().LA(1)
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// ISortbyContext is an interface to support dynamic dispatch.
type ISortbyContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	A_expr() IA_exprContext
	Opt_nulls_order() IOpt_nulls_orderContext
	USING() antlr.TerminalNode
	Qual_all_op() IQual_all_opContext
	Opt_asc_desc() IOpt_asc_descContext

	// IsSortbyContext differentiates from other interfaces.
	IsSortbyContext()
}

type SortbyContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptySortbyContext() *SortbyContext {
	var p = new(SortbyContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_sortby
	return p
}

func InitEmptySortbyContext(p *SortbyContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_sortby
}

func (*SortbyContext) IsSortbyContext() {}

func NewSortbyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SortbyContext {
	var p = new(SortbyContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_sortby

	return p
}

func (s *SortbyContext) GetParser() antlr.Parser { return s.parser }

func (s *SortbyContext) A_expr() IA_exprContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IA_exprContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IA_exprContext)
}

func (s *SortbyContext) Opt_nulls_order() IOpt_nulls_orderContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOpt_nulls_orderContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOpt_nulls_orderContext)
}

func (s *SortbyContext) USING() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserUSING, 0)
}

func (s *SortbyContext) Qual_all_op() IQual_all_opContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IQual_all_opContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IQual_all_opContext)
}

func (s *SortbyContext) Opt_asc_desc() IOpt_asc_descContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOpt_asc_descContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOpt_asc_descContext)
}

func (s *SortbyContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *SortbyContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *SortbyContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterSortby(s)
	}
}

func (s *SortbyContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitSortby(s)
	}
}

func (s *SortbyContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitSortby(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Sortby() (localctx ISortbyContext) {
	localctx = NewSortbyContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1002, PostgreSQLParserRULE_sortby)
	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(8104)
		p.A_expr()
	}
	p.SetState(8108)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetTokenStream().LA(1) {
	case PostgreSQLParserUSING:
		{
			p.SetState(8105)
			p.Match(PostgreSQLParserUSING)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(8106)
			p.Qual_all_op()
		}

	case PostgreSQLParserEOF, PostgreSQLParserOPEN_PAREN, PostgreSQLParserCLOSE_PAREN, PostgreSQLParserCOMMA, PostgreSQLParserSEMI, PostgreSQLParserANALYSE, PostgreSQLParserANALYZE, PostgreSQLParserASC, PostgreSQLParserCREATE, PostgreSQLParserDESC, PostgreSQLParserDO, PostgreSQLParserFETCH, PostgreSQLParserFOR, PostgreSQLParserGRANT, PostgreSQLParserINTO, PostgreSQLParserLIMIT, PostgreSQLParserOFFSET, PostgreSQLParserON, PostgreSQLParserRETURNING, PostgreSQLParserSELECT, PostgreSQLParserTABLE, PostgreSQLParserWITH, PostgreSQLParserABORT_P, PostgreSQLParserALTER, PostgreSQLParserBEGIN_P, PostgreSQLParserCHECKPOINT, PostgreSQLParserCLOSE, PostgreSQLParserCLUSTER, PostgreSQLParserCOMMENT, PostgreSQLParserCOMMIT, PostgreSQLParserCOPY, PostgreSQLParserDEALLOCATE, PostgreSQLParserDECLARE, PostgreSQLParserDELETE_P, PostgreSQLParserDISCARD, PostgreSQLParserDROP, PostgreSQLParserEXECUTE, PostgreSQLParserEXPLAIN, PostgreSQLParserINSERT, PostgreSQLParserLISTEN, PostgreSQLParserLOAD, PostgreSQLParserLOCK_P, PostgreSQLParserMERGE, PostgreSQLParserMOVE, PostgreSQLParserNOTIFY, PostgreSQLParserNULLS_P, PostgreSQLParserPREPARE, PostgreSQLParserRANGE, PostgreSQLParserREASSIGN, PostgreSQLParserREFRESH, PostgreSQLParserREINDEX, PostgreSQLParserRELEASE, PostgreSQLParserRESET, PostgreSQLParserREVOKE, PostgreSQLParserROLLBACK, PostgreSQLParserROWS, PostgreSQLParserSAVEPOINT, PostgreSQLParserSECURITY, PostgreSQLParserSET, PostgreSQLParserSHOW, PostgreSQLParserSTART, PostgreSQLParserTRUNCATE, PostgreSQLParserUNLISTEN, PostgreSQLParserUPDATE, PostgreSQLParserVACUUM, PostgreSQLParserVALUES, PostgreSQLParserCALL, PostgreSQLParserIMPORT_P, PostgreSQLParserEND_P, PostgreSQLParserGROUPS, PostgreSQLParserLOOP, PostgreSQLParserMetaCommand:
		{
			p.SetState(8107)
			p.Opt_asc_desc()
		}

	default:
		p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		goto errorExit
	}
	{
		p.SetState(8110)
		p.Opt_nulls_order()
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// ISelect_limitContext is an interface to support dynamic dispatch.
type ISelect_limitContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Limit_clause() ILimit_clauseContext
	Offset_clause() IOffset_clauseContext

	// IsSelect_limitContext differentiates from other interfaces.
	IsSelect_limitContext()
}

type Select_limitContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptySelect_limitContext() *Select_limitContext {
	var p = new(Select_limitContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_select_limit
	return p
}

func InitEmptySelect_limitContext(p *Select_limitContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_select_limit
}

func (*Select_limitContext) IsSelect_limitContext() {}

func NewSelect_limitContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Select_limitContext {
	var p = new(Select_limitContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_select_limit

	return p
}

func (s *Select_limitContext) GetParser() antlr.Parser { return s.parser }

func (s *Select_limitContext) Limit_clause() ILimit_clauseContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ILimit_clauseContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ILimit_clauseContext)
}

func (s *Select_limitContext) Offset_clause() IOffset_clauseContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOffset_clauseContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOffset_clauseContext)
}

func (s *Select_limitContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Select_limitContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Select_limitContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterSelect_limit(s)
	}
}

func (s *Select_limitContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitSelect_limit(s)
	}
}

func (s *Select_limitContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitSelect_limit(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Select_limit() (localctx ISelect_limitContext) {
	localctx = NewSelect_limitContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1004, PostgreSQLParserRULE_select_limit)
	var _la int

	p.SetState(8120)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetTokenStream().LA(1) {
	case PostgreSQLParserFETCH, PostgreSQLParserLIMIT:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(8112)
			p.Limit_clause()
		}
		p.SetState(8114)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}
		_la = p.GetTokenStream().LA(1)

		if _la == PostgreSQLParserOFFSET {
			{
				p.SetState(8113)
				p.Offset_clause()
			}

		}

	case PostgreSQLParserOFFSET:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(8116)
			p.Offset_clause()
		}
		p.SetState(8118)
		p.GetErrorHandler().Sync(p)

		if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 442, p.GetParserRuleContext()) == 1 {
			{
				p.SetState(8117)
				p.Limit_clause()
			}

		} else if p.HasError() { // JIM
			goto errorExit
		}

	default:
		p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IOpt_select_limitContext is an interface to support dynamic dispatch.
type IOpt_select_limitContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Select_limit() ISelect_limitContext

	// IsOpt_select_limitContext differentiates from other interfaces.
	IsOpt_select_limitContext()
}

type Opt_select_limitContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyOpt_select_limitContext() *Opt_select_limitContext {
	var p = new(Opt_select_limitContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opt_select_limit
	return p
}

func InitEmptyOpt_select_limitContext(p *Opt_select_limitContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opt_select_limit
}

func (*Opt_select_limitContext) IsOpt_select_limitContext() {}

func NewOpt_select_limitContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_select_limitContext {
	var p = new(Opt_select_limitContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_opt_select_limit

	return p
}

func (s *Opt_select_limitContext) GetParser() antlr.Parser { return s.parser }

func (s *Opt_select_limitContext) Select_limit() ISelect_limitContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ISelect_limitContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ISelect_limitContext)
}

func (s *Opt_select_limitContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Opt_select_limitContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Opt_select_limitContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterOpt_select_limit(s)
	}
}

func (s *Opt_select_limitContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitOpt_select_limit(s)
	}
}

func (s *Opt_select_limitContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitOpt_select_limit(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Opt_select_limit() (localctx IOpt_select_limitContext) {
	localctx = NewOpt_select_limitContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1006, PostgreSQLParserRULE_opt_select_limit)
	p.SetState(8124)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 444, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(8122)
			p.Select_limit()
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)

	case antlr.ATNInvalidAltNumber:
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// ILimit_clauseContext is an interface to support dynamic dispatch.
type ILimit_clauseContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	LIMIT() antlr.TerminalNode
	Select_limit_value() ISelect_limit_valueContext
	COMMA() antlr.TerminalNode
	Select_offset_value() ISelect_offset_valueContext
	FETCH() antlr.TerminalNode
	First_or_next() IFirst_or_nextContext
	Select_fetch_first_value() ISelect_fetch_first_valueContext
	Row_or_rows() IRow_or_rowsContext
	ONLY() antlr.TerminalNode
	WITH() antlr.TerminalNode
	TIES() antlr.TerminalNode

	// IsLimit_clauseContext differentiates from other interfaces.
	IsLimit_clauseContext()
}

type Limit_clauseContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyLimit_clauseContext() *Limit_clauseContext {
	var p = new(Limit_clauseContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_limit_clause
	return p
}

func InitEmptyLimit_clauseContext(p *Limit_clauseContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_limit_clause
}

func (*Limit_clauseContext) IsLimit_clauseContext() {}

func NewLimit_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Limit_clauseContext {
	var p = new(Limit_clauseContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_limit_clause

	return p
}

func (s *Limit_clauseContext) GetParser() antlr.Parser { return s.parser }

func (s *Limit_clauseContext) LIMIT() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserLIMIT, 0)
}

func (s *Limit_clauseContext) Select_limit_value() ISelect_limit_valueContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ISelect_limit_valueContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ISelect_limit_valueContext)
}

func (s *Limit_clauseContext) COMMA() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCOMMA, 0)
}

func (s *Limit_clauseContext) Select_offset_value() ISelect_offset_valueContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ISelect_offset_valueContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ISelect_offset_valueContext)
}

func (s *Limit_clauseContext) FETCH() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserFETCH, 0)
}

func (s *Limit_clauseContext) First_or_next() IFirst_or_nextContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IFirst_or_nextContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IFirst_or_nextContext)
}

func (s *Limit_clauseContext) Select_fetch_first_value() ISelect_fetch_first_valueContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ISelect_fetch_first_valueContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ISelect_fetch_first_valueContext)
}

func (s *Limit_clauseContext) Row_or_rows() IRow_or_rowsContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IRow_or_rowsContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IRow_or_rowsContext)
}

func (s *Limit_clauseContext) ONLY() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserONLY, 0)
}

func (s *Limit_clauseContext) WITH() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserWITH, 0)
}

func (s *Limit_clauseContext) TIES() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserTIES, 0)
}

func (s *Limit_clauseContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Limit_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Limit_clauseContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterLimit_clause(s)
	}
}

func (s *Limit_clauseContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitLimit_clause(s)
	}
}

func (s *Limit_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitLimit_clause(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Limit_clause() (localctx ILimit_clauseContext) {
	localctx = NewLimit_clauseContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1008, PostgreSQLParserRULE_limit_clause)
	var _la int

	p.SetState(8149)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetTokenStream().LA(1) {
	case PostgreSQLParserLIMIT:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(8126)
			p.Match(PostgreSQLParserLIMIT)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(8127)
			p.Select_limit_value()
		}
		p.SetState(8130)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}
		_la = p.GetTokenStream().LA(1)

		if _la == PostgreSQLParserCOMMA {
			{
				p.SetState(8128)
				p.Match(PostgreSQLParserCOMMA)
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}
			{
				p.SetState(8129)
				p.Select_offset_value()
			}

		}

	case PostgreSQLParserFETCH:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(8132)
			p.Match(PostgreSQLParserFETCH)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(8133)
			p.First_or_next()
		}
		p.SetState(8147)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}

		switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 448, p.GetParserRuleContext()) {
		case 1:
			{
				p.SetState(8134)
				p.Select_fetch_first_value()
			}
			{
				p.SetState(8135)
				p.Row_or_rows()
			}
			p.SetState(8139)
			p.GetErrorHandler().Sync(p)
			if p.HasError() {
				goto errorExit
			}

			switch p.GetTokenStream().LA(1) {
			case PostgreSQLParserONLY:
				{
					p.SetState(8136)
					p.Match(PostgreSQLParserONLY)
					if p.HasError() {
						// Recognition error - abort rule
						goto errorExit
					}
				}

			case PostgreSQLParserWITH:
				{
					p.SetState(8137)
					p.Match(PostgreSQLParserWITH)
					if p.HasError() {
						// Recognition error - abort rule
						goto errorExit
					}
				}
				{
					p.SetState(8138)
					p.Match(PostgreSQLParserTIES)
					if p.HasError() {
						// Recognition error - abort rule
						goto errorExit
					}
				}

			default:
				p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
				goto errorExit
			}

		case 2:
			{
				p.SetState(8141)
				p.Row_or_rows()
			}
			p.SetState(8145)
			p.GetErrorHandler().Sync(p)
			if p.HasError() {
				goto errorExit
			}

			switch p.GetTokenStream().LA(1) {
			case PostgreSQLParserONLY:
				{
					p.SetState(8142)
					p.Match(PostgreSQLParserONLY)
					if p.HasError() {
						// Recognition error - abort rule
						goto errorExit
					}
				}

			case PostgreSQLParserWITH:
				{
					p.SetState(8143)
					p.Match(PostgreSQLParserWITH)
					if p.HasError() {
						// Recognition error - abort rule
						goto errorExit
					}
				}
				{
					p.SetState(8144)
					p.Match(PostgreSQLParserTIES)
					if p.HasError() {
						// Recognition error - abort rule
						goto errorExit
					}
				}

			default:
				p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
				goto errorExit
			}

		case antlr.ATNInvalidAltNumber:
			goto errorExit
		}

	default:
		p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IOffset_clauseContext is an interface to support dynamic dispatch.
type IOffset_clauseContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	OFFSET() antlr.TerminalNode
	Select_offset_value() ISelect_offset_valueContext
	Select_fetch_first_value() ISelect_fetch_first_valueContext
	Row_or_rows() IRow_or_rowsContext

	// IsOffset_clauseContext differentiates from other interfaces.
	IsOffset_clauseContext()
}

type Offset_clauseContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyOffset_clauseContext() *Offset_clauseContext {
	var p = new(Offset_clauseContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_offset_clause
	return p
}

func InitEmptyOffset_clauseContext(p *Offset_clauseContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_offset_clause
}

func (*Offset_clauseContext) IsOffset_clauseContext() {}

func NewOffset_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Offset_clauseContext {
	var p = new(Offset_clauseContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_offset_clause

	return p
}

func (s *Offset_clauseContext) GetParser() antlr.Parser { return s.parser }

func (s *Offset_clauseContext) OFFSET() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserOFFSET, 0)
}

func (s *Offset_clauseContext) Select_offset_value() ISelect_offset_valueContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ISelect_offset_valueContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ISelect_offset_valueContext)
}

func (s *Offset_clauseContext) Select_fetch_first_value() ISelect_fetch_first_valueContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ISelect_fetch_first_valueContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ISelect_fetch_first_valueContext)
}

func (s *Offset_clauseContext) Row_or_rows() IRow_or_rowsContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IRow_or_rowsContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IRow_or_rowsContext)
}

func (s *Offset_clauseContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Offset_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Offset_clauseContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterOffset_clause(s)
	}
}

func (s *Offset_clauseContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitOffset_clause(s)
	}
}

func (s *Offset_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitOffset_clause(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Offset_clause() (localctx IOffset_clauseContext) {
	localctx = NewOffset_clauseContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1010, PostgreSQLParserRULE_offset_clause)
	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(8151)
		p.Match(PostgreSQLParserOFFSET)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	p.SetState(8156)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 450, p.GetParserRuleContext()) {
	case 1:
		{
			p.SetState(8152)
			p.Select_offset_value()
		}

	case 2:
		{
			p.SetState(8153)
			p.Select_fetch_first_value()
		}
		{
			p.SetState(8154)
			p.Row_or_rows()
		}

	case antlr.ATNInvalidAltNumber:
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// ISelect_limit_valueContext is an interface to support dynamic dispatch.
type ISelect_limit_valueContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	A_expr() IA_exprContext
	ALL() antlr.TerminalNode

	// IsSelect_limit_valueContext differentiates from other interfaces.
	IsSelect_limit_valueContext()
}

type Select_limit_valueContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptySelect_limit_valueContext() *Select_limit_valueContext {
	var p = new(Select_limit_valueContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_select_limit_value
	return p
}

func InitEmptySelect_limit_valueContext(p *Select_limit_valueContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_select_limit_value
}

func (*Select_limit_valueContext) IsSelect_limit_valueContext() {}

func NewSelect_limit_valueContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Select_limit_valueContext {
	var p = new(Select_limit_valueContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_select_limit_value

	return p
}

func (s *Select_limit_valueContext) GetParser() antlr.Parser { return s.parser }

func (s *Select_limit_valueContext) A_expr() IA_exprContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IA_exprContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IA_exprContext)
}

func (s *Select_limit_valueContext) ALL() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserALL, 0)
}

func (s *Select_limit_valueContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Select_limit_valueContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Select_limit_valueContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterSelect_limit_value(s)
	}
}

func (s *Select_limit_valueContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitSelect_limit_value(s)
	}
}

func (s *Select_limit_valueContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitSelect_limit_value(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Select_limit_value() (localctx ISelect_limit_valueContext) {
	localctx = NewSelect_limit_valueContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1012, PostgreSQLParserRULE_select_limit_value)
	p.SetState(8160)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetTokenStream().LA(1) {
	case PostgreSQLParserOPEN_PAREN, PostgreSQLParserPLUS, PostgreSQLParserMINUS, PostgreSQLParserPARAM, PostgreSQLParserOperator, PostgreSQLParserAND, PostgreSQLParserARRAY, PostgreSQLParserCASE, PostgreSQLParserCAST, PostgreSQLParserCOLLATE, PostgreSQLParserCOLUMN, PostgreSQLParserCONSTRAINT, PostgreSQLParserCURRENT_CATALOG, PostgreSQLParserCURRENT_DATE, PostgreSQLParserCURRENT_ROLE, PostgreSQLParserCURRENT_TIME, PostgreSQLParserCURRENT_TIMESTAMP, PostgreSQLParserCURRENT_USER, PostgreSQLParserDEFAULT, PostgreSQLParserDO, PostgreSQLParserFALSE_P, PostgreSQLParserFETCH, PostgreSQLParserLOCALTIME, PostgreSQLParserLOCALTIMESTAMP, PostgreSQLParserNOT, PostgreSQLParserNULL_P, PostgreSQLParserSESSION_USER, PostgreSQLParserTABLE, PostgreSQLParserTRUE_P, PostgreSQLParserUNIQUE, PostgreSQLParserUSER, PostgreSQLParserAUTHORIZATION, PostgreSQLParserBINARY, PostgreSQLParserCOLLATION, PostgreSQLParserCONCURRENTLY, PostgreSQLParserCROSS, PostgreSQLParserCURRENT_SCHEMA, PostgreSQLParserFREEZE, PostgreSQLParserFULL, PostgreSQLParserILIKE, PostgreSQLParserINNER_P, PostgreSQLParserIS, PostgreSQLParserISNULL, PostgreSQLParserJOIN, PostgreSQLParserLEFT, PostgreSQLParserLIKE, PostgreSQLParserNATURAL, PostgreSQLParserNOTNULL, PostgreSQLParserOUTER_P, PostgreSQLParserOVER, PostgreSQLParserOVERLAPS, PostgreSQLParserRIGHT, PostgreSQLParserSIMILAR, PostgreSQLParserVERBOSE, PostgreSQLParserABORT_P, PostgreSQLParserABSOLUTE_P, PostgreSQLParserACCESS, PostgreSQLParserACTION, PostgreSQLParserADD_P, PostgreSQLParserADMIN, PostgreSQLParserAFTER, PostgreSQLParserAGGREGATE, PostgreSQLParserALSO, PostgreSQLParserALTER, PostgreSQLParserALWAYS, PostgreSQLParserASSERTION, PostgreSQLParserASSIGNMENT, PostgreSQLParserAT, PostgreSQLParserATTRIBUTE, PostgreSQLParserBACKWARD, PostgreSQLParserBEFORE, PostgreSQLParserBEGIN_P, PostgreSQLParserBY, PostgreSQLParserCACHE, PostgreSQLParserCALLED, PostgreSQLParserCASCADE, PostgreSQLParserCASCADED, PostgreSQLParserCATALOG, PostgreSQLParserCHAIN, PostgreSQLParserCHARACTERISTICS, PostgreSQLParserCHECKPOINT, PostgreSQLParserCLASS, PostgreSQLParserCLOSE, PostgreSQLParserCLUSTER, PostgreSQLParserCOMMENT, PostgreSQLParserCOMMENTS, PostgreSQLParserCOMMIT, PostgreSQLParserCOMMITTED, PostgreSQLParserCONFIGURATION, PostgreSQLParserCONNECTION, PostgreSQLParserCONSTRAINTS, PostgreSQLParserCONTENT_P, PostgreSQLParserCONTINUE_P, PostgreSQLParserCONVERSION_P, PostgreSQLParserCOPY, PostgreSQLParserCOST, PostgreSQLParserCSV, PostgreSQLParserCURSOR, PostgreSQLParserCYCLE, PostgreSQLParserDATA_P, PostgreSQLParserDATABASE, PostgreSQLParserDAY_P, PostgreSQLParserDEALLOCATE, PostgreSQLParserDECLARE, PostgreSQLParserDEFAULTS, PostgreSQLParserDEFERRED, PostgreSQLParserDEFINER, PostgreSQLParserDELETE_P, PostgreSQLParserDELIMITER, PostgreSQLParserDELIMITERS, PostgreSQLParserDICTIONARY, PostgreSQLParserDISABLE_P, PostgreSQLParserDISCARD, PostgreSQLParserDOCUMENT_P, PostgreSQLParserDOMAIN_P, PostgreSQLParserDOUBLE_P, PostgreSQLParserDROP, PostgreSQLParserEACH, PostgreSQLParserENABLE_P, PostgreSQLParserENCODING, PostgreSQLParserENCRYPTED, PostgreSQLParserENUM_P, PostgreSQLParserESCAPE, PostgreSQLParserEVENT, PostgreSQLParserEXCLUDE, PostgreSQLParserEXCLUDING, PostgreSQLParserEXCLUSIVE, PostgreSQLParserEXECUTE, PostgreSQLParserEXPLAIN, PostgreSQLParserEXTENSION, PostgreSQLParserEXTERNAL, PostgreSQLParserFAMILY, PostgreSQLParserFIRST_P, PostgreSQLParserFOLLOWING, PostgreSQLParserFORCE, PostgreSQLParserFORWARD, PostgreSQLParserFUNCTION, PostgreSQLParserFUNCTIONS, PostgreSQLParserGLOBAL, PostgreSQLParserGRANTED, PostgreSQLParserHANDLER, PostgreSQLParserHEADER_P, PostgreSQLParserHOLD, PostgreSQLParserHOUR_P, PostgreSQLParserIDENTITY_P, PostgreSQLParserIF_P, PostgreSQLParserIMMEDIATE, PostgreSQLParserIMMUTABLE, PostgreSQLParserIMPLICIT_P, PostgreSQLParserINCLUDING, PostgreSQLParserINCREMENT, PostgreSQLParserINDEX, PostgreSQLParserINDEXES, PostgreSQLParserINHERIT, PostgreSQLParserINHERITS, PostgreSQLParserINLINE_P, PostgreSQLParserINSENSITIVE, PostgreSQLParserINSERT, PostgreSQLParserINSTEAD, PostgreSQLParserINVOKER, PostgreSQLParserISOLATION, PostgreSQLParserKEY, PostgreSQLParserLABEL, PostgreSQLParserLANGUAGE, PostgreSQLParserLARGE_P, PostgreSQLParserLAST_P, PostgreSQLParserLEAKPROOF, PostgreSQLParserLEVEL, PostgreSQLParserLISTEN, PostgreSQLParserLOAD, PostgreSQLParserLOCAL, PostgreSQLParserLOCATION, PostgreSQLParserLOCK_P, PostgreSQLParserMAPPING, PostgreSQLParserMATCH, PostgreSQLParserMATERIALIZED, PostgreSQLParserMAXVALUE, PostgreSQLParserMINUTE_P, PostgreSQLParserMINVALUE, PostgreSQLParserMODE, PostgreSQLParserMONTH_P, PostgreSQLParserMOVE, PostgreSQLParserNAME_P, PostgreSQLParserNAMES, PostgreSQLParserNEXT, PostgreSQLParserNO, PostgreSQLParserNOTHING, PostgreSQLParserNOTIFY, PostgreSQLParserNOWAIT, PostgreSQLParserNULLS_P, PostgreSQLParserOBJECT_P, PostgreSQLParserOF, PostgreSQLParserOFF, PostgreSQLParserOIDS, PostgreSQLParserOPERATOR, PostgreSQLParserOPTION, PostgreSQLParserOPTIONS, PostgreSQLParserOWNED, PostgreSQLParserOWNER, PostgreSQLParserPARSER, PostgreSQLParserPARTIAL, PostgreSQLParserPARTITION, PostgreSQLParserPASSING, PostgreSQLParserPASSWORD, PostgreSQLParserPLANS, PostgreSQLParserPRECEDING, PostgreSQLParserPREPARE, PostgreSQLParserPREPARED, PostgreSQLParserPRESERVE, PostgreSQLParserPRIOR, PostgreSQLParserPRIVILEGES, PostgreSQLParserPROCEDURAL, PostgreSQLParserPROCEDURE, PostgreSQLParserPROGRAM, PostgreSQLParserQUOTE, PostgreSQLParserRANGE, PostgreSQLParserREAD, PostgreSQLParserREASSIGN, PostgreSQLParserRECHECK, PostgreSQLParserRECURSIVE, PostgreSQLParserREF, PostgreSQLParserREFRESH, PostgreSQLParserREINDEX, PostgreSQLParserRELATIVE_P, PostgreSQLParserRELEASE, PostgreSQLParserRENAME, PostgreSQLParserREPEATABLE, PostgreSQLParserREPLACE, PostgreSQLParserREPLICA, PostgreSQLParserRESET, PostgreSQLParserRESTART, PostgreSQLParserRESTRICT, PostgreSQLParserRETURNS, PostgreSQLParserREVOKE, PostgreSQLParserROLE, PostgreSQLParserROLLBACK, PostgreSQLParserROWS, PostgreSQLParserRULE, PostgreSQLParserSAVEPOINT, PostgreSQLParserSCHEMA, PostgreSQLParserSCROLL, PostgreSQLParserSEARCH, PostgreSQLParserSECOND_P, PostgreSQLParserSECURITY, PostgreSQLParserSEQUENCE, PostgreSQLParserSEQUENCES, PostgreSQLParserSERIALIZABLE, PostgreSQLParserSERVER, PostgreSQLParserSESSION, PostgreSQLParserSET, PostgreSQLParserSHARE, PostgreSQLParserSHOW, PostgreSQLParserSIMPLE, PostgreSQLParserSNAPSHOT, PostgreSQLParserSTABLE, PostgreSQLParserSTANDALONE_P, PostgreSQLParserSTART, PostgreSQLParserSTATEMENT, PostgreSQLParserSTATISTICS, PostgreSQLParserSTDIN, PostgreSQLParserSTDOUT, PostgreSQLParserSTORAGE, PostgreSQLParserSTRICT_P, PostgreSQLParserSTRIP_P, PostgreSQLParserSYSID, PostgreSQLParserSYSTEM_P, PostgreSQLParserTABLES, PostgreSQLParserTABLESPACE, PostgreSQLParserTEMP, PostgreSQLParserTEMPLATE, PostgreSQLParserTEMPORARY, PostgreSQLParserTEXT_P, PostgreSQLParserTRANSACTION, PostgreSQLParserTRIGGER, PostgreSQLParserTRUNCATE, PostgreSQLParserTRUSTED, PostgreSQLParserTYPE_P, PostgreSQLParserTYPES_P, PostgreSQLParserUNBOUNDED, PostgreSQLParserUNCOMMITTED, PostgreSQLParserUNENCRYPTED, PostgreSQLParserUNKNOWN, PostgreSQLParserUNLISTEN, PostgreSQLParserUNLOGGED, PostgreSQLParserUNTIL, PostgreSQLParserUPDATE, PostgreSQLParserVACUUM, PostgreSQLParserVALID, PostgreSQLParserVALIDATE, PostgreSQLParserVALIDATOR, PostgreSQLParserVARYING, PostgreSQLParserVERSION_P, PostgreSQLParserVIEW, PostgreSQLParserVOLATILE, PostgreSQLParserWHITESPACE_P, PostgreSQLParserWITHOUT, PostgreSQLParserWORK, PostgreSQLParserWRAPPER, PostgreSQLParserWRITE, PostgreSQLParserXML_P, PostgreSQLParserYEAR_P, PostgreSQLParserYES_P, PostgreSQLParserZONE, PostgreSQLParserBETWEEN, PostgreSQLParserBIGINT, PostgreSQLParserBIT, PostgreSQLParserBOOLEAN_P, PostgreSQLParserCHAR_P, PostgreSQLParserCHARACTER, PostgreSQLParserCOALESCE, PostgreSQLParserDEC, PostgreSQLParserDECIMAL_P, PostgreSQLParserEXISTS, PostgreSQLParserEXTRACT, PostgreSQLParserFLOAT_P, PostgreSQLParserGREATEST, PostgreSQLParserINOUT, PostgreSQLParserINT_P, PostgreSQLParserINTEGER, PostgreSQLParserINTERVAL, PostgreSQLParserLEAST, PostgreSQLParserNATIONAL, PostgreSQLParserNCHAR, PostgreSQLParserNONE, PostgreSQLParserNULLIF, PostgreSQLParserNUMERIC, PostgreSQLParserOVERLAY, PostgreSQLParserPOSITION, PostgreSQLParserPRECISION, PostgreSQLParserREAL, PostgreSQLParserROW, PostgreSQLParserSETOF, PostgreSQLParserSMALLINT, PostgreSQLParserSUBSTRING, PostgreSQLParserTIME, PostgreSQLParserTIMESTAMP, PostgreSQLParserTREAT, PostgreSQLParserTRIM, PostgreSQLParserVALUES, PostgreSQLParserVARCHAR, PostgreSQLParserXMLATTRIBUTES, PostgreSQLParserXMLCOMMENT, PostgreSQLParserXMLAGG, PostgreSQLParserXML_IS_WELL_FORMED, PostgreSQLParserXML_IS_WELL_FORMED_DOCUMENT, PostgreSQLParserXML_IS_WELL_FORMED_CONTENT, PostgreSQLParserXPATH, PostgreSQLParserXPATH_EXISTS, PostgreSQLParserXMLCONCAT, PostgreSQLParserXMLELEMENT, PostgreSQLParserXMLEXISTS, PostgreSQLParserXMLFOREST, PostgreSQLParserXMLPARSE, PostgreSQLParserXMLPI, PostgreSQLParserXMLROOT, PostgreSQLParserXMLSERIALIZE, PostgreSQLParserCALL, PostgreSQLParserCURRENT_P, PostgreSQLParserATTACH, PostgreSQLParserDETACH, PostgreSQLParserEXPRESSION, PostgreSQLParserGENERATED, PostgreSQLParserLOGGED, PostgreSQLParserSTORED, PostgreSQLParserINCLUDE, PostgreSQLParserROUTINE, PostgreSQLParserTRANSFORM, PostgreSQLParserIMPORT_P, PostgreSQLParserPOLICY, PostgreSQLParserMETHOD, PostgreSQLParserREFERENCING, PostgreSQLParserNEW, PostgreSQLParserOLD, PostgreSQLParserVALUE_P, PostgreSQLParserSUBSCRIPTION, PostgreSQLParserPUBLICATION, PostgreSQLParserOUT_P, PostgreSQLParserROUTINES, PostgreSQLParserSCHEMAS, PostgreSQLParserPROCEDURES, PostgreSQLParserINPUT_P, PostgreSQLParserSUPPORT, PostgreSQLParserPARALLEL, PostgreSQLParserSQL_P, PostgreSQLParserDEPENDS, PostgreSQLParserOVERRIDING, PostgreSQLParserCONFLICT, PostgreSQLParserSKIP_P, PostgreSQLParserLOCKED, PostgreSQLParserTIES, PostgreSQLParserROLLUP, PostgreSQLParserCUBE, PostgreSQLParserGROUPING, PostgreSQLParserSETS, PostgreSQLParserTABLESAMPLE, PostgreSQLParserORDINALITY, PostgreSQLParserXMLTABLE, PostgreSQLParserCOLUMNS, PostgreSQLParserXMLNAMESPACES, PostgreSQLParserROWTYPE, PostgreSQLParserNORMALIZED, PostgreSQLParserWITHIN, PostgreSQLParserFILTER, PostgreSQLParserGROUPS, PostgreSQLParserOTHERS, PostgreSQLParserNFC, PostgreSQLParserNFD, PostgreSQLParserNFKC, PostgreSQLParserNFKD, PostgreSQLParserUESCAPE, PostgreSQLParserVIEWS, PostgreSQLParserNORMALIZE, PostgreSQLParserDUMP, PostgreSQLParserPRINT_STRICT_PARAMS, PostgreSQLParserVARIABLE_CONFLICT, PostgreSQLParserERROR, PostgreSQLParserUSE_VARIABLE, PostgreSQLParserUSE_COLUMN, PostgreSQLParserALIAS, PostgreSQLParserCONSTANT, PostgreSQLParserPERFORM, PostgreSQLParserGET, PostgreSQLParserDIAGNOSTICS, PostgreSQLParserSTACKED, PostgreSQLParserELSIF, PostgreSQLParserREVERSE, PostgreSQLParserSLICE, PostgreSQLParserEXIT, PostgreSQLParserRETURN, PostgreSQLParserQUERY, PostgreSQLParserRAISE, PostgreSQLParserSQLSTATE, PostgreSQLParserDEBUG, PostgreSQLParserLOG, PostgreSQLParserINFO, PostgreSQLParserNOTICE, PostgreSQLParserWARNING, PostgreSQLParserEXCEPTION, PostgreSQLParserASSERT, PostgreSQLParserOPEN, PostgreSQLParserABS, PostgreSQLParserCBRT, PostgreSQLParserCEIL, PostgreSQLParserCEILING, PostgreSQLParserDEGREES, PostgreSQLParserDIV, PostgreSQLParserEXP, PostgreSQLParserFACTORIAL, PostgreSQLParserFLOOR, PostgreSQLParserGCD, PostgreSQLParserLCM, PostgreSQLParserLN, PostgreSQLParserLOG10, PostgreSQLParserMIN_SCALE, PostgreSQLParserMOD, PostgreSQLParserPI, PostgreSQLParserPOWER, PostgreSQLParserRADIANS, PostgreSQLParserROUND, PostgreSQLParserSCALE, PostgreSQLParserSIGN, PostgreSQLParserSQRT, PostgreSQLParserTRIM_SCALE, PostgreSQLParserTRUNC, PostgreSQLParserWIDTH_BUCKET, PostgreSQLParserRANDOM, PostgreSQLParserSETSEED, PostgreSQLParserACOS, PostgreSQLParserACOSD, PostgreSQLParserASIN, PostgreSQLParserASIND, PostgreSQLParserATAN, PostgreSQLParserATAND, PostgreSQLParserATAN2, PostgreSQLParserATAN2D, PostgreSQLParserCOS, PostgreSQLParserCOSD, PostgreSQLParserCOT, PostgreSQLParserCOTD, PostgreSQLParserSIN, PostgreSQLParserSIND, PostgreSQLParserTAN, PostgreSQLParserTAND, PostgreSQLParserSINH, PostgreSQLParserCOSH, PostgreSQLParserTANH, PostgreSQLParserASINH, PostgreSQLParserACOSH, PostgreSQLParserATANH, PostgreSQLParserBIT_LENGTH, PostgreSQLParserCHAR_LENGTH, PostgreSQLParserCHARACTER_LENGTH, PostgreSQLParserLOWER, PostgreSQLParserOCTET_LENGTH, PostgreSQLParserUPPER, PostgreSQLParserASCII, PostgreSQLParserBTRIM, PostgreSQLParserCHR, PostgreSQLParserCONCAT, PostgreSQLParserCONCAT_WS, PostgreSQLParserFORMAT, PostgreSQLParserINITCAP, PostgreSQLParserLENGTH, PostgreSQLParserLPAD, PostgreSQLParserLTRIM, PostgreSQLParserMD5, PostgreSQLParserPARSE_IDENT, PostgreSQLParserPG_CLIENT_ENCODING, PostgreSQLParserQUOTE_IDENT, PostgreSQLParserQUOTE_LITERAL, PostgreSQLParserQUOTE_NULLABLE, PostgreSQLParserREGEXP_COUNT, PostgreSQLParserREGEXP_INSTR, PostgreSQLParserREGEXP_LIKE, PostgreSQLParserREGEXP_MATCH, PostgreSQLParserREGEXP_MATCHES, PostgreSQLParserREGEXP_REPLACE, PostgreSQLParserREGEXP_SPLIT_TO_ARRAY, PostgreSQLParserREGEXP_SPLIT_TO_TABLE, PostgreSQLParserREGEXP_SUBSTR, PostgreSQLParserREPEAT, PostgreSQLParserRPAD, PostgreSQLParserRTRIM, PostgreSQLParserSPLIT_PART, PostgreSQLParserSTARTS_WITH, PostgreSQLParserSTRING_TO_ARRAY, PostgreSQLParserSTRING_TO_TABLE, PostgreSQLParserSTRPOS, PostgreSQLParserSUBSTR, PostgreSQLParserTO_ASCII, PostgreSQLParserTO_HEX, PostgreSQLParserTRANSLATE, PostgreSQLParserUNISTR, PostgreSQLParserAGE, PostgreSQLParserCLOCK_TIMESTAMP, PostgreSQLParserDATE_BIN, PostgreSQLParserDATE_PART, PostgreSQLParserDATE_TRUNC, PostgreSQLParserISFINITE, PostgreSQLParserJUSTIFY_DAYS, PostgreSQLParserJUSTIFY_HOURS, PostgreSQLParserJUSTIFY_INTERVAL, PostgreSQLParserMAKE_DATE, PostgreSQLParserMAKE_INTERVAL, PostgreSQLParserMAKE_TIME, PostgreSQLParserMAKE_TIMESTAMP, PostgreSQLParserMAKE_TIMESTAMPTZ, PostgreSQLParserNOW, PostgreSQLParserSTATEMENT_TIMESTAMP, PostgreSQLParserTIMEOFDAY, PostgreSQLParserTRANSACTION_TIMESTAMP, PostgreSQLParserTO_TIMESTAMP, PostgreSQLParserTO_CHAR, PostgreSQLParserTO_DATE, PostgreSQLParserTO_NUMBER, PostgreSQLParserIdentifier, PostgreSQLParserQuotedIdentifier, PostgreSQLParserUnicodeQuotedIdentifier, PostgreSQLParserStringConstant, PostgreSQLParserUnicodeEscapeStringConstant, PostgreSQLParserBeginDollarStringConstant, PostgreSQLParserBinaryStringConstant, PostgreSQLParserHexadecimalStringConstant, PostgreSQLParserIntegral, PostgreSQLParserNumeric, PostgreSQLParserPLSQLVARIABLENAME, PostgreSQLParserPLSQLIDENTIFIER, PostgreSQLParserEscapeStringConstant:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(8158)
			p.A_expr()
		}

	case PostgreSQLParserALL:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(8159)
			p.Match(PostgreSQLParserALL)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	default:
		p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// ISelect_offset_valueContext is an interface to support dynamic dispatch.
type ISelect_offset_valueContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	A_expr() IA_exprContext

	// IsSelect_offset_valueContext differentiates from other interfaces.
	IsSelect_offset_valueContext()
}

type Select_offset_valueContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptySelect_offset_valueContext() *Select_offset_valueContext {
	var p = new(Select_offset_valueContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_select_offset_value
	return p
}

func InitEmptySelect_offset_valueContext(p *Select_offset_valueContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_select_offset_value
}

func (*Select_offset_valueContext) IsSelect_offset_valueContext() {}

func NewSelect_offset_valueContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Select_offset_valueContext {
	var p = new(Select_offset_valueContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_select_offset_value

	return p
}

func (s *Select_offset_valueContext) GetParser() antlr.Parser { return s.parser }

func (s *Select_offset_valueContext) A_expr() IA_exprContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IA_exprContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IA_exprContext)
}

func (s *Select_offset_valueContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Select_offset_valueContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Select_offset_valueContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterSelect_offset_value(s)
	}
}

func (s *Select_offset_valueContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitSelect_offset_value(s)
	}
}

func (s *Select_offset_valueContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitSelect_offset_value(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Select_offset_value() (localctx ISelect_offset_valueContext) {
	localctx = NewSelect_offset_valueContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1014, PostgreSQLParserRULE_select_offset_value)
	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(8162)
		p.A_expr()
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// ISelect_fetch_first_valueContext is an interface to support dynamic dispatch.
type ISelect_fetch_first_valueContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	C_expr() IC_exprContext
	PLUS() antlr.TerminalNode
	I_or_f_const() II_or_f_constContext
	MINUS() antlr.TerminalNode

	// IsSelect_fetch_first_valueContext differentiates from other interfaces.
	IsSelect_fetch_first_valueContext()
}

type Select_fetch_first_valueContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptySelect_fetch_first_valueContext() *Select_fetch_first_valueContext {
	var p = new(Select_fetch_first_valueContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_select_fetch_first_value
	return p
}

func InitEmptySelect_fetch_first_valueContext(p *Select_fetch_first_valueContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_select_fetch_first_value
}

func (*Select_fetch_first_valueContext) IsSelect_fetch_first_valueContext() {}

func NewSelect_fetch_first_valueContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Select_fetch_first_valueContext {
	var p = new(Select_fetch_first_valueContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_select_fetch_first_value

	return p
}

func (s *Select_fetch_first_valueContext) GetParser() antlr.Parser { return s.parser }

func (s *Select_fetch_first_valueContext) C_expr() IC_exprContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IC_exprContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IC_exprContext)
}

func (s *Select_fetch_first_valueContext) PLUS() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserPLUS, 0)
}

func (s *Select_fetch_first_valueContext) I_or_f_const() II_or_f_constContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(II_or_f_constContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(II_or_f_constContext)
}

func (s *Select_fetch_first_valueContext) MINUS() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserMINUS, 0)
}

func (s *Select_fetch_first_valueContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Select_fetch_first_valueContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Select_fetch_first_valueContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterSelect_fetch_first_value(s)
	}
}

func (s *Select_fetch_first_valueContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitSelect_fetch_first_value(s)
	}
}

func (s *Select_fetch_first_valueContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitSelect_fetch_first_value(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Select_fetch_first_value() (localctx ISelect_fetch_first_valueContext) {
	localctx = NewSelect_fetch_first_valueContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1016, PostgreSQLParserRULE_select_fetch_first_value)
	p.SetState(8169)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetTokenStream().LA(1) {
	case PostgreSQLParserOPEN_PAREN, PostgreSQLParserPARAM, PostgreSQLParserAND, PostgreSQLParserARRAY, PostgreSQLParserCASE, PostgreSQLParserCAST, PostgreSQLParserCOLLATE, PostgreSQLParserCOLUMN, PostgreSQLParserCONSTRAINT, PostgreSQLParserCURRENT_CATALOG, PostgreSQLParserCURRENT_DATE, PostgreSQLParserCURRENT_ROLE, PostgreSQLParserCURRENT_TIME, PostgreSQLParserCURRENT_TIMESTAMP, PostgreSQLParserCURRENT_USER, PostgreSQLParserDEFAULT, PostgreSQLParserDO, PostgreSQLParserFALSE_P, PostgreSQLParserFETCH, PostgreSQLParserLOCALTIME, PostgreSQLParserLOCALTIMESTAMP, PostgreSQLParserNULL_P, PostgreSQLParserSESSION_USER, PostgreSQLParserTABLE, PostgreSQLParserTRUE_P, PostgreSQLParserUNIQUE, PostgreSQLParserUSER, PostgreSQLParserAUTHORIZATION, PostgreSQLParserBINARY, PostgreSQLParserCOLLATION, PostgreSQLParserCONCURRENTLY, PostgreSQLParserCROSS, PostgreSQLParserCURRENT_SCHEMA, PostgreSQLParserFREEZE, PostgreSQLParserFULL, PostgreSQLParserILIKE, PostgreSQLParserINNER_P, PostgreSQLParserIS, PostgreSQLParserISNULL, PostgreSQLParserJOIN, PostgreSQLParserLEFT, PostgreSQLParserLIKE, PostgreSQLParserNATURAL, PostgreSQLParserNOTNULL, PostgreSQLParserOUTER_P, PostgreSQLParserOVER, PostgreSQLParserOVERLAPS, PostgreSQLParserRIGHT, PostgreSQLParserSIMILAR, PostgreSQLParserVERBOSE, PostgreSQLParserABORT_P, PostgreSQLParserABSOLUTE_P, PostgreSQLParserACCESS, PostgreSQLParserACTION, PostgreSQLParserADD_P, PostgreSQLParserADMIN, PostgreSQLParserAFTER, PostgreSQLParserAGGREGATE, PostgreSQLParserALSO, PostgreSQLParserALTER, PostgreSQLParserALWAYS, PostgreSQLParserASSERTION, PostgreSQLParserASSIGNMENT, PostgreSQLParserAT, PostgreSQLParserATTRIBUTE, PostgreSQLParserBACKWARD, PostgreSQLParserBEFORE, PostgreSQLParserBEGIN_P, PostgreSQLParserBY, PostgreSQLParserCACHE, PostgreSQLParserCALLED, PostgreSQLParserCASCADE, PostgreSQLParserCASCADED, PostgreSQLParserCATALOG, PostgreSQLParserCHAIN, PostgreSQLParserCHARACTERISTICS, PostgreSQLParserCHECKPOINT, PostgreSQLParserCLASS, PostgreSQLParserCLOSE, PostgreSQLParserCLUSTER, PostgreSQLParserCOMMENT, PostgreSQLParserCOMMENTS, PostgreSQLParserCOMMIT, PostgreSQLParserCOMMITTED, PostgreSQLParserCONFIGURATION, PostgreSQLParserCONNECTION, PostgreSQLParserCONSTRAINTS, PostgreSQLParserCONTENT_P, PostgreSQLParserCONTINUE_P, PostgreSQLParserCONVERSION_P, PostgreSQLParserCOPY, PostgreSQLParserCOST, PostgreSQLParserCSV, PostgreSQLParserCURSOR, PostgreSQLParserCYCLE, PostgreSQLParserDATA_P, PostgreSQLParserDATABASE, PostgreSQLParserDAY_P, PostgreSQLParserDEALLOCATE, PostgreSQLParserDECLARE, PostgreSQLParserDEFAULTS, PostgreSQLParserDEFERRED, PostgreSQLParserDEFINER, PostgreSQLParserDELETE_P, PostgreSQLParserDELIMITER, PostgreSQLParserDELIMITERS, PostgreSQLParserDICTIONARY, PostgreSQLParserDISABLE_P, PostgreSQLParserDISCARD, PostgreSQLParserDOCUMENT_P, PostgreSQLParserDOMAIN_P, PostgreSQLParserDOUBLE_P, PostgreSQLParserDROP, PostgreSQLParserEACH, PostgreSQLParserENABLE_P, PostgreSQLParserENCODING, PostgreSQLParserENCRYPTED, PostgreSQLParserENUM_P, PostgreSQLParserESCAPE, PostgreSQLParserEVENT, PostgreSQLParserEXCLUDE, PostgreSQLParserEXCLUDING, PostgreSQLParserEXCLUSIVE, PostgreSQLParserEXECUTE, PostgreSQLParserEXPLAIN, PostgreSQLParserEXTENSION, PostgreSQLParserEXTERNAL, PostgreSQLParserFAMILY, PostgreSQLParserFIRST_P, PostgreSQLParserFOLLOWING, PostgreSQLParserFORCE, PostgreSQLParserFORWARD, PostgreSQLParserFUNCTION, PostgreSQLParserFUNCTIONS, PostgreSQLParserGLOBAL, PostgreSQLParserGRANTED, PostgreSQLParserHANDLER, PostgreSQLParserHEADER_P, PostgreSQLParserHOLD, PostgreSQLParserHOUR_P, PostgreSQLParserIDENTITY_P, PostgreSQLParserIF_P, PostgreSQLParserIMMEDIATE, PostgreSQLParserIMMUTABLE, PostgreSQLParserIMPLICIT_P, PostgreSQLParserINCLUDING, PostgreSQLParserINCREMENT, PostgreSQLParserINDEX, PostgreSQLParserINDEXES, PostgreSQLParserINHERIT, PostgreSQLParserINHERITS, PostgreSQLParserINLINE_P, PostgreSQLParserINSENSITIVE, PostgreSQLParserINSERT, PostgreSQLParserINSTEAD, PostgreSQLParserINVOKER, PostgreSQLParserISOLATION, PostgreSQLParserKEY, PostgreSQLParserLABEL, PostgreSQLParserLANGUAGE, PostgreSQLParserLARGE_P, PostgreSQLParserLAST_P, PostgreSQLParserLEAKPROOF, PostgreSQLParserLEVEL, PostgreSQLParserLISTEN, PostgreSQLParserLOAD, PostgreSQLParserLOCAL, PostgreSQLParserLOCATION, PostgreSQLParserLOCK_P, PostgreSQLParserMAPPING, PostgreSQLParserMATCH, PostgreSQLParserMATERIALIZED, PostgreSQLParserMAXVALUE, PostgreSQLParserMINUTE_P, PostgreSQLParserMINVALUE, PostgreSQLParserMODE, PostgreSQLParserMONTH_P, PostgreSQLParserMOVE, PostgreSQLParserNAME_P, PostgreSQLParserNAMES, PostgreSQLParserNEXT, PostgreSQLParserNO, PostgreSQLParserNOTHING, PostgreSQLParserNOTIFY, PostgreSQLParserNOWAIT, PostgreSQLParserNULLS_P, PostgreSQLParserOBJECT_P, PostgreSQLParserOF, PostgreSQLParserOFF, PostgreSQLParserOIDS, PostgreSQLParserOPERATOR, PostgreSQLParserOPTION, PostgreSQLParserOPTIONS, PostgreSQLParserOWNED, PostgreSQLParserOWNER, PostgreSQLParserPARSER, PostgreSQLParserPARTIAL, PostgreSQLParserPARTITION, PostgreSQLParserPASSING, PostgreSQLParserPASSWORD, PostgreSQLParserPLANS, PostgreSQLParserPRECEDING, PostgreSQLParserPREPARE, PostgreSQLParserPREPARED, PostgreSQLParserPRESERVE, PostgreSQLParserPRIOR, PostgreSQLParserPRIVILEGES, PostgreSQLParserPROCEDURAL, PostgreSQLParserPROCEDURE, PostgreSQLParserPROGRAM, PostgreSQLParserQUOTE, PostgreSQLParserRANGE, PostgreSQLParserREAD, PostgreSQLParserREASSIGN, PostgreSQLParserRECHECK, PostgreSQLParserRECURSIVE, PostgreSQLParserREF, PostgreSQLParserREFRESH, PostgreSQLParserREINDEX, PostgreSQLParserRELATIVE_P, PostgreSQLParserRELEASE, PostgreSQLParserRENAME, PostgreSQLParserREPEATABLE, PostgreSQLParserREPLACE, PostgreSQLParserREPLICA, PostgreSQLParserRESET, PostgreSQLParserRESTART, PostgreSQLParserRESTRICT, PostgreSQLParserRETURNS, PostgreSQLParserREVOKE, PostgreSQLParserROLE, PostgreSQLParserROLLBACK, PostgreSQLParserROWS, PostgreSQLParserRULE, PostgreSQLParserSAVEPOINT, PostgreSQLParserSCHEMA, PostgreSQLParserSCROLL, PostgreSQLParserSEARCH, PostgreSQLParserSECOND_P, PostgreSQLParserSECURITY, PostgreSQLParserSEQUENCE, PostgreSQLParserSEQUENCES, PostgreSQLParserSERIALIZABLE, PostgreSQLParserSERVER, PostgreSQLParserSESSION, PostgreSQLParserSET, PostgreSQLParserSHARE, PostgreSQLParserSHOW, PostgreSQLParserSIMPLE, PostgreSQLParserSNAPSHOT, PostgreSQLParserSTABLE, PostgreSQLParserSTANDALONE_P, PostgreSQLParserSTART, PostgreSQLParserSTATEMENT, PostgreSQLParserSTATISTICS, PostgreSQLParserSTDIN, PostgreSQLParserSTDOUT, PostgreSQLParserSTORAGE, PostgreSQLParserSTRICT_P, PostgreSQLParserSTRIP_P, PostgreSQLParserSYSID, PostgreSQLParserSYSTEM_P, PostgreSQLParserTABLES, PostgreSQLParserTABLESPACE, PostgreSQLParserTEMP, PostgreSQLParserTEMPLATE, PostgreSQLParserTEMPORARY, PostgreSQLParserTEXT_P, PostgreSQLParserTRANSACTION, PostgreSQLParserTRIGGER, PostgreSQLParserTRUNCATE, PostgreSQLParserTRUSTED, PostgreSQLParserTYPE_P, PostgreSQLParserTYPES_P, PostgreSQLParserUNBOUNDED, PostgreSQLParserUNCOMMITTED, PostgreSQLParserUNENCRYPTED, PostgreSQLParserUNKNOWN, PostgreSQLParserUNLISTEN, PostgreSQLParserUNLOGGED, PostgreSQLParserUNTIL, PostgreSQLParserUPDATE, PostgreSQLParserVACUUM, PostgreSQLParserVALID, PostgreSQLParserVALIDATE, PostgreSQLParserVALIDATOR, PostgreSQLParserVARYING, PostgreSQLParserVERSION_P, PostgreSQLParserVIEW, PostgreSQLParserVOLATILE, PostgreSQLParserWHITESPACE_P, PostgreSQLParserWITHOUT, PostgreSQLParserWORK, PostgreSQLParserWRAPPER, PostgreSQLParserWRITE, PostgreSQLParserXML_P, PostgreSQLParserYEAR_P, PostgreSQLParserYES_P, PostgreSQLParserZONE, PostgreSQLParserBETWEEN, PostgreSQLParserBIGINT, PostgreSQLParserBIT, PostgreSQLParserBOOLEAN_P, PostgreSQLParserCHAR_P, PostgreSQLParserCHARACTER, PostgreSQLParserCOALESCE, PostgreSQLParserDEC, PostgreSQLParserDECIMAL_P, PostgreSQLParserEXISTS, PostgreSQLParserEXTRACT, PostgreSQLParserFLOAT_P, PostgreSQLParserGREATEST, PostgreSQLParserINOUT, PostgreSQLParserINT_P, PostgreSQLParserINTEGER, PostgreSQLParserINTERVAL, PostgreSQLParserLEAST, PostgreSQLParserNATIONAL, PostgreSQLParserNCHAR, PostgreSQLParserNONE, PostgreSQLParserNULLIF, PostgreSQLParserNUMERIC, PostgreSQLParserOVERLAY, PostgreSQLParserPOSITION, PostgreSQLParserPRECISION, PostgreSQLParserREAL, PostgreSQLParserROW, PostgreSQLParserSETOF, PostgreSQLParserSMALLINT, PostgreSQLParserSUBSTRING, PostgreSQLParserTIME, PostgreSQLParserTIMESTAMP, PostgreSQLParserTREAT, PostgreSQLParserTRIM, PostgreSQLParserVALUES, PostgreSQLParserVARCHAR, PostgreSQLParserXMLATTRIBUTES, PostgreSQLParserXMLCOMMENT, PostgreSQLParserXMLAGG, PostgreSQLParserXML_IS_WELL_FORMED, PostgreSQLParserXML_IS_WELL_FORMED_DOCUMENT, PostgreSQLParserXML_IS_WELL_FORMED_CONTENT, PostgreSQLParserXPATH, PostgreSQLParserXPATH_EXISTS, PostgreSQLParserXMLCONCAT, PostgreSQLParserXMLELEMENT, PostgreSQLParserXMLEXISTS, PostgreSQLParserXMLFOREST, PostgreSQLParserXMLPARSE, PostgreSQLParserXMLPI, PostgreSQLParserXMLROOT, PostgreSQLParserXMLSERIALIZE, PostgreSQLParserCALL, PostgreSQLParserCURRENT_P, PostgreSQLParserATTACH, PostgreSQLParserDETACH, PostgreSQLParserEXPRESSION, PostgreSQLParserGENERATED, PostgreSQLParserLOGGED, PostgreSQLParserSTORED, PostgreSQLParserINCLUDE, PostgreSQLParserROUTINE, PostgreSQLParserTRANSFORM, PostgreSQLParserIMPORT_P, PostgreSQLParserPOLICY, PostgreSQLParserMETHOD, PostgreSQLParserREFERENCING, PostgreSQLParserNEW, PostgreSQLParserOLD, PostgreSQLParserVALUE_P, PostgreSQLParserSUBSCRIPTION, PostgreSQLParserPUBLICATION, PostgreSQLParserOUT_P, PostgreSQLParserROUTINES, PostgreSQLParserSCHEMAS, PostgreSQLParserPROCEDURES, PostgreSQLParserINPUT_P, PostgreSQLParserSUPPORT, PostgreSQLParserPARALLEL, PostgreSQLParserSQL_P, PostgreSQLParserDEPENDS, PostgreSQLParserOVERRIDING, PostgreSQLParserCONFLICT, PostgreSQLParserSKIP_P, PostgreSQLParserLOCKED, PostgreSQLParserTIES, PostgreSQLParserROLLUP, PostgreSQLParserCUBE, PostgreSQLParserGROUPING, PostgreSQLParserSETS, PostgreSQLParserTABLESAMPLE, PostgreSQLParserORDINALITY, PostgreSQLParserXMLTABLE, PostgreSQLParserCOLUMNS, PostgreSQLParserXMLNAMESPACES, PostgreSQLParserROWTYPE, PostgreSQLParserNORMALIZED, PostgreSQLParserWITHIN, PostgreSQLParserFILTER, PostgreSQLParserGROUPS, PostgreSQLParserOTHERS, PostgreSQLParserNFC, PostgreSQLParserNFD, PostgreSQLParserNFKC, PostgreSQLParserNFKD, PostgreSQLParserUESCAPE, PostgreSQLParserVIEWS, PostgreSQLParserNORMALIZE, PostgreSQLParserDUMP, PostgreSQLParserPRINT_STRICT_PARAMS, PostgreSQLParserVARIABLE_CONFLICT, PostgreSQLParserERROR, PostgreSQLParserUSE_VARIABLE, PostgreSQLParserUSE_COLUMN, PostgreSQLParserALIAS, PostgreSQLParserCONSTANT, PostgreSQLParserPERFORM, PostgreSQLParserGET, PostgreSQLParserDIAGNOSTICS, PostgreSQLParserSTACKED, PostgreSQLParserELSIF, PostgreSQLParserREVERSE, PostgreSQLParserSLICE, PostgreSQLParserEXIT, PostgreSQLParserRETURN, PostgreSQLParserQUERY, PostgreSQLParserRAISE, PostgreSQLParserSQLSTATE, PostgreSQLParserDEBUG, PostgreSQLParserLOG, PostgreSQLParserINFO, PostgreSQLParserNOTICE, PostgreSQLParserWARNING, PostgreSQLParserEXCEPTION, PostgreSQLParserASSERT, PostgreSQLParserOPEN, PostgreSQLParserABS, PostgreSQLParserCBRT, PostgreSQLParserCEIL, PostgreSQLParserCEILING, PostgreSQLParserDEGREES, PostgreSQLParserDIV, PostgreSQLParserEXP, PostgreSQLParserFACTORIAL, PostgreSQLParserFLOOR, PostgreSQLParserGCD, PostgreSQLParserLCM, PostgreSQLParserLN, PostgreSQLParserLOG10, PostgreSQLParserMIN_SCALE, PostgreSQLParserMOD, PostgreSQLParserPI, PostgreSQLParserPOWER, PostgreSQLParserRADIANS, PostgreSQLParserROUND, PostgreSQLParserSCALE, PostgreSQLParserSIGN, PostgreSQLParserSQRT, PostgreSQLParserTRIM_SCALE, PostgreSQLParserTRUNC, PostgreSQLParserWIDTH_BUCKET, PostgreSQLParserRANDOM, PostgreSQLParserSETSEED, PostgreSQLParserACOS, PostgreSQLParserACOSD, PostgreSQLParserASIN, PostgreSQLParserASIND, PostgreSQLParserATAN, PostgreSQLParserATAND, PostgreSQLParserATAN2, PostgreSQLParserATAN2D, PostgreSQLParserCOS, PostgreSQLParserCOSD, PostgreSQLParserCOT, PostgreSQLParserCOTD, PostgreSQLParserSIN, PostgreSQLParserSIND, PostgreSQLParserTAN, PostgreSQLParserTAND, PostgreSQLParserSINH, PostgreSQLParserCOSH, PostgreSQLParserTANH, PostgreSQLParserASINH, PostgreSQLParserACOSH, PostgreSQLParserATANH, PostgreSQLParserBIT_LENGTH, PostgreSQLParserCHAR_LENGTH, PostgreSQLParserCHARACTER_LENGTH, PostgreSQLParserLOWER, PostgreSQLParserOCTET_LENGTH, PostgreSQLParserUPPER, PostgreSQLParserASCII, PostgreSQLParserBTRIM, PostgreSQLParserCHR, PostgreSQLParserCONCAT, PostgreSQLParserCONCAT_WS, PostgreSQLParserFORMAT, PostgreSQLParserINITCAP, PostgreSQLParserLENGTH, PostgreSQLParserLPAD, PostgreSQLParserLTRIM, PostgreSQLParserMD5, PostgreSQLParserPARSE_IDENT, PostgreSQLParserPG_CLIENT_ENCODING, PostgreSQLParserQUOTE_IDENT, PostgreSQLParserQUOTE_LITERAL, PostgreSQLParserQUOTE_NULLABLE, PostgreSQLParserREGEXP_COUNT, PostgreSQLParserREGEXP_INSTR, PostgreSQLParserREGEXP_LIKE, PostgreSQLParserREGEXP_MATCH, PostgreSQLParserREGEXP_MATCHES, PostgreSQLParserREGEXP_REPLACE, PostgreSQLParserREGEXP_SPLIT_TO_ARRAY, PostgreSQLParserREGEXP_SPLIT_TO_TABLE, PostgreSQLParserREGEXP_SUBSTR, PostgreSQLParserREPEAT, PostgreSQLParserRPAD, PostgreSQLParserRTRIM, PostgreSQLParserSPLIT_PART, PostgreSQLParserSTARTS_WITH, PostgreSQLParserSTRING_TO_ARRAY, PostgreSQLParserSTRING_TO_TABLE, PostgreSQLParserSTRPOS, PostgreSQLParserSUBSTR, PostgreSQLParserTO_ASCII, PostgreSQLParserTO_HEX, PostgreSQLParserTRANSLATE, PostgreSQLParserUNISTR, PostgreSQLParserAGE, PostgreSQLParserCLOCK_TIMESTAMP, PostgreSQLParserDATE_BIN, PostgreSQLParserDATE_PART, PostgreSQLParserDATE_TRUNC, PostgreSQLParserISFINITE, PostgreSQLParserJUSTIFY_DAYS, PostgreSQLParserJUSTIFY_HOURS, PostgreSQLParserJUSTIFY_INTERVAL, PostgreSQLParserMAKE_DATE, PostgreSQLParserMAKE_INTERVAL, PostgreSQLParserMAKE_TIME, PostgreSQLParserMAKE_TIMESTAMP, PostgreSQLParserMAKE_TIMESTAMPTZ, PostgreSQLParserNOW, PostgreSQLParserSTATEMENT_TIMESTAMP, PostgreSQLParserTIMEOFDAY, PostgreSQLParserTRANSACTION_TIMESTAMP, PostgreSQLParserTO_TIMESTAMP, PostgreSQLParserTO_CHAR, PostgreSQLParserTO_DATE, PostgreSQLParserTO_NUMBER, PostgreSQLParserIdentifier, PostgreSQLParserQuotedIdentifier, PostgreSQLParserUnicodeQuotedIdentifier, PostgreSQLParserStringConstant, PostgreSQLParserUnicodeEscapeStringConstant, PostgreSQLParserBeginDollarStringConstant, PostgreSQLParserBinaryStringConstant, PostgreSQLParserHexadecimalStringConstant, PostgreSQLParserIntegral, PostgreSQLParserNumeric, PostgreSQLParserPLSQLVARIABLENAME, PostgreSQLParserPLSQLIDENTIFIER, PostgreSQLParserEscapeStringConstant:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(8164)
			p.C_expr()
		}

	case PostgreSQLParserPLUS:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(8165)
			p.Match(PostgreSQLParserPLUS)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(8166)
			p.I_or_f_const()
		}

	case PostgreSQLParserMINUS:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(8167)
			p.Match(PostgreSQLParserMINUS)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(8168)
			p.I_or_f_const()
		}

	default:
		p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// II_or_f_constContext is an interface to support dynamic dispatch.
type II_or_f_constContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Iconst() IIconstContext
	Fconst() IFconstContext

	// IsI_or_f_constContext differentiates from other interfaces.
	IsI_or_f_constContext()
}

type I_or_f_constContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyI_or_f_constContext() *I_or_f_constContext {
	var p = new(I_or_f_constContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_i_or_f_const
	return p
}

func InitEmptyI_or_f_constContext(p *I_or_f_constContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_i_or_f_const
}

func (*I_or_f_constContext) IsI_or_f_constContext() {}

func NewI_or_f_constContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *I_or_f_constContext {
	var p = new(I_or_f_constContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_i_or_f_const

	return p
}

func (s *I_or_f_constContext) GetParser() antlr.Parser { return s.parser }

func (s *I_or_f_constContext) Iconst() IIconstContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IIconstContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IIconstContext)
}

func (s *I_or_f_constContext) Fconst() IFconstContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IFconstContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IFconstContext)
}

func (s *I_or_f_constContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *I_or_f_constContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *I_or_f_constContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterI_or_f_const(s)
	}
}

func (s *I_or_f_constContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitI_or_f_const(s)
	}
}

func (s *I_or_f_constContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitI_or_f_const(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) I_or_f_const() (localctx II_or_f_constContext) {
	localctx = NewI_or_f_constContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1018, PostgreSQLParserRULE_i_or_f_const)
	p.SetState(8173)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetTokenStream().LA(1) {
	case PostgreSQLParserIntegral:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(8171)
			p.Iconst()
		}

	case PostgreSQLParserNumeric:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(8172)
			p.Fconst()
		}

	default:
		p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IRow_or_rowsContext is an interface to support dynamic dispatch.
type IRow_or_rowsContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	ROW() antlr.TerminalNode
	ROWS() antlr.TerminalNode

	// IsRow_or_rowsContext differentiates from other interfaces.
	IsRow_or_rowsContext()
}

type Row_or_rowsContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyRow_or_rowsContext() *Row_or_rowsContext {
	var p = new(Row_or_rowsContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_row_or_rows
	return p
}

func InitEmptyRow_or_rowsContext(p *Row_or_rowsContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_row_or_rows
}

func (*Row_or_rowsContext) IsRow_or_rowsContext() {}

func NewRow_or_rowsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Row_or_rowsContext {
	var p = new(Row_or_rowsContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_row_or_rows

	return p
}

func (s *Row_or_rowsContext) GetParser() antlr.Parser { return s.parser }

func (s *Row_or_rowsContext) ROW() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserROW, 0)
}

func (s *Row_or_rowsContext) ROWS() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserROWS, 0)
}

func (s *Row_or_rowsContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Row_or_rowsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Row_or_rowsContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterRow_or_rows(s)
	}
}

func (s *Row_or_rowsContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitRow_or_rows(s)
	}
}

func (s *Row_or_rowsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitRow_or_rows(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Row_or_rows() (localctx IRow_or_rowsContext) {
	localctx = NewRow_or_rowsContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1020, PostgreSQLParserRULE_row_or_rows)
	var _la int

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(8175)
		_la = p.GetTokenStream().LA(1)

		if !(_la == PostgreSQLParserROWS || _la == PostgreSQLParserROW) {
			p.GetErrorHandler().RecoverInline(p)
		} else {
			p.GetErrorHandler().ReportMatch(p)
			p.Consume()
		}
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IFirst_or_nextContext is an interface to support dynamic dispatch.
type IFirst_or_nextContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	FIRST_P() antlr.TerminalNode
	NEXT() antlr.TerminalNode

	// IsFirst_or_nextContext differentiates from other interfaces.
	IsFirst_or_nextContext()
}

type First_or_nextContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyFirst_or_nextContext() *First_or_nextContext {
	var p = new(First_or_nextContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_first_or_next
	return p
}

func InitEmptyFirst_or_nextContext(p *First_or_nextContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_first_or_next
}

func (*First_or_nextContext) IsFirst_or_nextContext() {}

func NewFirst_or_nextContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *First_or_nextContext {
	var p = new(First_or_nextContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_first_or_next

	return p
}

func (s *First_or_nextContext) GetParser() antlr.Parser { return s.parser }

func (s *First_or_nextContext) FIRST_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserFIRST_P, 0)
}

func (s *First_or_nextContext) NEXT() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserNEXT, 0)
}

func (s *First_or_nextContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *First_or_nextContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *First_or_nextContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterFirst_or_next(s)
	}
}

func (s *First_or_nextContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitFirst_or_next(s)
	}
}

func (s *First_or_nextContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitFirst_or_next(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) First_or_next() (localctx IFirst_or_nextContext) {
	localctx = NewFirst_or_nextContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1022, PostgreSQLParserRULE_first_or_next)
	var _la int

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(8177)
		_la = p.GetTokenStream().LA(1)

		if !(_la == PostgreSQLParserFIRST_P || _la == PostgreSQLParserNEXT) {
			p.GetErrorHandler().RecoverInline(p)
		} else {
			p.GetErrorHandler().ReportMatch(p)
			p.Consume()
		}
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IGroup_clauseContext is an interface to support dynamic dispatch.
type IGroup_clauseContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	GROUP_P() antlr.TerminalNode
	BY() antlr.TerminalNode
	Group_by_list() IGroup_by_listContext

	// IsGroup_clauseContext differentiates from other interfaces.
	IsGroup_clauseContext()
}

type Group_clauseContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyGroup_clauseContext() *Group_clauseContext {
	var p = new(Group_clauseContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_group_clause
	return p
}

func InitEmptyGroup_clauseContext(p *Group_clauseContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_group_clause
}

func (*Group_clauseContext) IsGroup_clauseContext() {}

func NewGroup_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Group_clauseContext {
	var p = new(Group_clauseContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_group_clause

	return p
}

func (s *Group_clauseContext) GetParser() antlr.Parser { return s.parser }

func (s *Group_clauseContext) GROUP_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserGROUP_P, 0)
}

func (s *Group_clauseContext) BY() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserBY, 0)
}

func (s *Group_clauseContext) Group_by_list() IGroup_by_listContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IGroup_by_listContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IGroup_by_listContext)
}

func (s *Group_clauseContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Group_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Group_clauseContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterGroup_clause(s)
	}
}

func (s *Group_clauseContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitGroup_clause(s)
	}
}

func (s *Group_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitGroup_clause(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Group_clause() (localctx IGroup_clauseContext) {
	localctx = NewGroup_clauseContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1024, PostgreSQLParserRULE_group_clause)
	p.SetState(8183)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetTokenStream().LA(1) {
	case PostgreSQLParserGROUP_P:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(8179)
			p.Match(PostgreSQLParserGROUP_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(8180)
			p.Match(PostgreSQLParserBY)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(8181)
			p.Group_by_list()
		}

	case PostgreSQLParserEOF, PostgreSQLParserOPEN_PAREN, PostgreSQLParserCLOSE_PAREN, PostgreSQLParserCOMMA, PostgreSQLParserSEMI, PostgreSQLParserANALYSE, PostgreSQLParserANALYZE, PostgreSQLParserCREATE, PostgreSQLParserDO, PostgreSQLParserEXCEPT, PostgreSQLParserFETCH, PostgreSQLParserFOR, PostgreSQLParserGRANT, PostgreSQLParserHAVING, PostgreSQLParserINTERSECT, PostgreSQLParserINTO, PostgreSQLParserLIMIT, PostgreSQLParserOFFSET, PostgreSQLParserON, PostgreSQLParserORDER, PostgreSQLParserRETURNING, PostgreSQLParserSELECT, PostgreSQLParserTABLE, PostgreSQLParserTHEN, PostgreSQLParserUNION, PostgreSQLParserUSING, PostgreSQLParserWHEN, PostgreSQLParserWINDOW, PostgreSQLParserWITH, PostgreSQLParserABORT_P, PostgreSQLParserALTER, PostgreSQLParserBEGIN_P, PostgreSQLParserCHECKPOINT, PostgreSQLParserCLOSE, PostgreSQLParserCLUSTER, PostgreSQLParserCOMMENT, PostgreSQLParserCOMMIT, PostgreSQLParserCOPY, PostgreSQLParserDEALLOCATE, PostgreSQLParserDECLARE, PostgreSQLParserDELETE_P, PostgreSQLParserDISCARD, PostgreSQLParserDROP, PostgreSQLParserEXECUTE, PostgreSQLParserEXPLAIN, PostgreSQLParserINSERT, PostgreSQLParserLISTEN, PostgreSQLParserLOAD, PostgreSQLParserLOCK_P, PostgreSQLParserMERGE, PostgreSQLParserMOVE, PostgreSQLParserNOTIFY, PostgreSQLParserPREPARE, PostgreSQLParserREASSIGN, PostgreSQLParserREFRESH, PostgreSQLParserREINDEX, PostgreSQLParserRELEASE, PostgreSQLParserRESET, PostgreSQLParserREVOKE, PostgreSQLParserROLLBACK, PostgreSQLParserSAVEPOINT, PostgreSQLParserSECURITY, PostgreSQLParserSET, PostgreSQLParserSHOW, PostgreSQLParserSTART, PostgreSQLParserTRUNCATE, PostgreSQLParserUNLISTEN, PostgreSQLParserUPDATE, PostgreSQLParserVACUUM, PostgreSQLParserVALUES, PostgreSQLParserCALL, PostgreSQLParserIMPORT_P, PostgreSQLParserEND_P, PostgreSQLParserLOOP, PostgreSQLParserMetaCommand:
		p.EnterOuterAlt(localctx, 2)

	default:
		p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IGroup_by_listContext is an interface to support dynamic dispatch.
type IGroup_by_listContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	AllGroup_by_item() []IGroup_by_itemContext
	Group_by_item(i int) IGroup_by_itemContext
	AllCOMMA() []antlr.TerminalNode
	COMMA(i int) antlr.TerminalNode

	// IsGroup_by_listContext differentiates from other interfaces.
	IsGroup_by_listContext()
}

type Group_by_listContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyGroup_by_listContext() *Group_by_listContext {
	var p = new(Group_by_listContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_group_by_list
	return p
}

func InitEmptyGroup_by_listContext(p *Group_by_listContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_group_by_list
}

func (*Group_by_listContext) IsGroup_by_listContext() {}

func NewGroup_by_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Group_by_listContext {
	var p = new(Group_by_listContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_group_by_list

	return p
}

func (s *Group_by_listContext) GetParser() antlr.Parser { return s.parser }

func (s *Group_by_listContext) AllGroup_by_item() []IGroup_by_itemContext {
	children := s.GetChildren()
	len := 0
	for _, ctx := range children {
		if _, ok := ctx.(IGroup_by_itemContext); ok {
			len++
		}
	}

	tst := make([]IGroup_by_itemContext, len)
	i := 0
	for _, ctx := range children {
		if t, ok := ctx.(IGroup_by_itemContext); ok {
			tst[i] = t.(IGroup_by_itemContext)
			i++
		}
	}

	return tst
}

func (s *Group_by_listContext) Group_by_item(i int) IGroup_by_itemContext {
	var t antlr.RuleContext
	j := 0
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IGroup_by_itemContext); ok {
			if j == i {
				t = ctx.(antlr.RuleContext)
				break
			}
			j++
		}
	}

	if t == nil {
		return nil
	}

	return t.(IGroup_by_itemContext)
}

func (s *Group_by_listContext) AllCOMMA() []antlr.TerminalNode {
	return s.GetTokens(PostgreSQLParserCOMMA)
}

func (s *Group_by_listContext) COMMA(i int) antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCOMMA, i)
}

func (s *Group_by_listContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Group_by_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Group_by_listContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterGroup_by_list(s)
	}
}

func (s *Group_by_listContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitGroup_by_list(s)
	}
}

func (s *Group_by_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitGroup_by_list(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Group_by_list() (localctx IGroup_by_listContext) {
	localctx = NewGroup_by_listContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1026, PostgreSQLParserRULE_group_by_list)
	var _alt int

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(8185)
		p.Group_by_item()
	}
	p.SetState(8190)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}
	_alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 455, p.GetParserRuleContext())
	if p.HasError() {
		goto errorExit
	}
	for _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
		if _alt == 1 {
			{
				p.SetState(8186)
				p.Match(PostgreSQLParserCOMMA)
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}
			{
				p.SetState(8187)
				p.Group_by_item()
			}

		}
		p.SetState(8192)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}
		_alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 455, p.GetParserRuleContext())
		if p.HasError() {
			goto errorExit
		}
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IGroup_by_itemContext is an interface to support dynamic dispatch.
type IGroup_by_itemContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Empty_grouping_set() IEmpty_grouping_setContext
	Cube_clause() ICube_clauseContext
	Rollup_clause() IRollup_clauseContext
	Grouping_sets_clause() IGrouping_sets_clauseContext
	A_expr() IA_exprContext

	// IsGroup_by_itemContext differentiates from other interfaces.
	IsGroup_by_itemContext()
}

type Group_by_itemContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyGroup_by_itemContext() *Group_by_itemContext {
	var p = new(Group_by_itemContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_group_by_item
	return p
}

func InitEmptyGroup_by_itemContext(p *Group_by_itemContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_group_by_item
}

func (*Group_by_itemContext) IsGroup_by_itemContext() {}

func NewGroup_by_itemContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Group_by_itemContext {
	var p = new(Group_by_itemContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_group_by_item

	return p
}

func (s *Group_by_itemContext) GetParser() antlr.Parser { return s.parser }

func (s *Group_by_itemContext) Empty_grouping_set() IEmpty_grouping_setContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IEmpty_grouping_setContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IEmpty_grouping_setContext)
}

func (s *Group_by_itemContext) Cube_clause() ICube_clauseContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ICube_clauseContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ICube_clauseContext)
}

func (s *Group_by_itemContext) Rollup_clause() IRollup_clauseContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IRollup_clauseContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IRollup_clauseContext)
}

func (s *Group_by_itemContext) Grouping_sets_clause() IGrouping_sets_clauseContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IGrouping_sets_clauseContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IGrouping_sets_clauseContext)
}

func (s *Group_by_itemContext) A_expr() IA_exprContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IA_exprContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IA_exprContext)
}

func (s *Group_by_itemContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Group_by_itemContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Group_by_itemContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterGroup_by_item(s)
	}
}

func (s *Group_by_itemContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitGroup_by_item(s)
	}
}

func (s *Group_by_itemContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitGroup_by_item(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Group_by_item() (localctx IGroup_by_itemContext) {
	localctx = NewGroup_by_itemContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1028, PostgreSQLParserRULE_group_by_item)
	p.SetState(8198)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 456, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(8193)
			p.Empty_grouping_set()
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(8194)
			p.Cube_clause()
		}

	case 3:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(8195)
			p.Rollup_clause()
		}

	case 4:
		p.EnterOuterAlt(localctx, 4)
		{
			p.SetState(8196)
			p.Grouping_sets_clause()
		}

	case 5:
		p.EnterOuterAlt(localctx, 5)
		{
			p.SetState(8197)
			p.A_expr()
		}

	case antlr.ATNInvalidAltNumber:
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IEmpty_grouping_setContext is an interface to support dynamic dispatch.
type IEmpty_grouping_setContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	OPEN_PAREN() antlr.TerminalNode
	CLOSE_PAREN() antlr.TerminalNode

	// IsEmpty_grouping_setContext differentiates from other interfaces.
	IsEmpty_grouping_setContext()
}

type Empty_grouping_setContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyEmpty_grouping_setContext() *Empty_grouping_setContext {
	var p = new(Empty_grouping_setContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_empty_grouping_set
	return p
}

func InitEmptyEmpty_grouping_setContext(p *Empty_grouping_setContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_empty_grouping_set
}

func (*Empty_grouping_setContext) IsEmpty_grouping_setContext() {}

func NewEmpty_grouping_setContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Empty_grouping_setContext {
	var p = new(Empty_grouping_setContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_empty_grouping_set

	return p
}

func (s *Empty_grouping_setContext) GetParser() antlr.Parser { return s.parser }

func (s *Empty_grouping_setContext) OPEN_PAREN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserOPEN_PAREN, 0)
}

func (s *Empty_grouping_setContext) CLOSE_PAREN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCLOSE_PAREN, 0)
}

func (s *Empty_grouping_setContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Empty_grouping_setContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Empty_grouping_setContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterEmpty_grouping_set(s)
	}
}

func (s *Empty_grouping_setContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitEmpty_grouping_set(s)
	}
}

func (s *Empty_grouping_setContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitEmpty_grouping_set(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Empty_grouping_set() (localctx IEmpty_grouping_setContext) {
	localctx = NewEmpty_grouping_setContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1030, PostgreSQLParserRULE_empty_grouping_set)
	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(8200)
		p.Match(PostgreSQLParserOPEN_PAREN)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(8201)
		p.Match(PostgreSQLParserCLOSE_PAREN)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IRollup_clauseContext is an interface to support dynamic dispatch.
type IRollup_clauseContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	ROLLUP() antlr.TerminalNode
	OPEN_PAREN() antlr.TerminalNode
	Expr_list() IExpr_listContext
	CLOSE_PAREN() antlr.TerminalNode

	// IsRollup_clauseContext differentiates from other interfaces.
	IsRollup_clauseContext()
}

type Rollup_clauseContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyRollup_clauseContext() *Rollup_clauseContext {
	var p = new(Rollup_clauseContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_rollup_clause
	return p
}

func InitEmptyRollup_clauseContext(p *Rollup_clauseContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_rollup_clause
}

func (*Rollup_clauseContext) IsRollup_clauseContext() {}

func NewRollup_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Rollup_clauseContext {
	var p = new(Rollup_clauseContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_rollup_clause

	return p
}

func (s *Rollup_clauseContext) GetParser() antlr.Parser { return s.parser }

func (s *Rollup_clauseContext) ROLLUP() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserROLLUP, 0)
}

func (s *Rollup_clauseContext) OPEN_PAREN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserOPEN_PAREN, 0)
}

func (s *Rollup_clauseContext) Expr_list() IExpr_listContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IExpr_listContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IExpr_listContext)
}

func (s *Rollup_clauseContext) CLOSE_PAREN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCLOSE_PAREN, 0)
}

func (s *Rollup_clauseContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Rollup_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Rollup_clauseContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterRollup_clause(s)
	}
}

func (s *Rollup_clauseContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitRollup_clause(s)
	}
}

func (s *Rollup_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitRollup_clause(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Rollup_clause() (localctx IRollup_clauseContext) {
	localctx = NewRollup_clauseContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1032, PostgreSQLParserRULE_rollup_clause)
	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(8203)
		p.Match(PostgreSQLParserROLLUP)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(8204)
		p.Match(PostgreSQLParserOPEN_PAREN)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(8205)
		p.Expr_list()
	}
	{
		p.SetState(8206)
		p.Match(PostgreSQLParserCLOSE_PAREN)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// ICube_clauseContext is an interface to support dynamic dispatch.
type ICube_clauseContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	CUBE() antlr.TerminalNode
	OPEN_PAREN() antlr.TerminalNode
	Expr_list() IExpr_listContext
	CLOSE_PAREN() antlr.TerminalNode

	// IsCube_clauseContext differentiates from other interfaces.
	IsCube_clauseContext()
}

type Cube_clauseContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyCube_clauseContext() *Cube_clauseContext {
	var p = new(Cube_clauseContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_cube_clause
	return p
}

func InitEmptyCube_clauseContext(p *Cube_clauseContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_cube_clause
}

func (*Cube_clauseContext) IsCube_clauseContext() {}

func NewCube_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Cube_clauseContext {
	var p = new(Cube_clauseContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_cube_clause

	return p
}

func (s *Cube_clauseContext) GetParser() antlr.Parser { return s.parser }

func (s *Cube_clauseContext) CUBE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCUBE, 0)
}

func (s *Cube_clauseContext) OPEN_PAREN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserOPEN_PAREN, 0)
}

func (s *Cube_clauseContext) Expr_list() IExpr_listContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IExpr_listContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IExpr_listContext)
}

func (s *Cube_clauseContext) CLOSE_PAREN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCLOSE_PAREN, 0)
}

func (s *Cube_clauseContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Cube_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Cube_clauseContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterCube_clause(s)
	}
}

func (s *Cube_clauseContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitCube_clause(s)
	}
}

func (s *Cube_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitCube_clause(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Cube_clause() (localctx ICube_clauseContext) {
	localctx = NewCube_clauseContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1034, PostgreSQLParserRULE_cube_clause)
	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(8208)
		p.Match(PostgreSQLParserCUBE)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(8209)
		p.Match(PostgreSQLParserOPEN_PAREN)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(8210)
		p.Expr_list()
	}
	{
		p.SetState(8211)
		p.Match(PostgreSQLParserCLOSE_PAREN)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IGrouping_sets_clauseContext is an interface to support dynamic dispatch.
type IGrouping_sets_clauseContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	GROUPING() antlr.TerminalNode
	SETS() antlr.TerminalNode
	OPEN_PAREN() antlr.TerminalNode
	Group_by_list() IGroup_by_listContext
	CLOSE_PAREN() antlr.TerminalNode

	// IsGrouping_sets_clauseContext differentiates from other interfaces.
	IsGrouping_sets_clauseContext()
}

type Grouping_sets_clauseContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyGrouping_sets_clauseContext() *Grouping_sets_clauseContext {
	var p = new(Grouping_sets_clauseContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_grouping_sets_clause
	return p
}

func InitEmptyGrouping_sets_clauseContext(p *Grouping_sets_clauseContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_grouping_sets_clause
}

func (*Grouping_sets_clauseContext) IsGrouping_sets_clauseContext() {}

func NewGrouping_sets_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Grouping_sets_clauseContext {
	var p = new(Grouping_sets_clauseContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_grouping_sets_clause

	return p
}

func (s *Grouping_sets_clauseContext) GetParser() antlr.Parser { return s.parser }

func (s *Grouping_sets_clauseContext) GROUPING() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserGROUPING, 0)
}

func (s *Grouping_sets_clauseContext) SETS() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserSETS, 0)
}

func (s *Grouping_sets_clauseContext) OPEN_PAREN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserOPEN_PAREN, 0)
}

func (s *Grouping_sets_clauseContext) Group_by_list() IGroup_by_listContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IGroup_by_listContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IGroup_by_listContext)
}

func (s *Grouping_sets_clauseContext) CLOSE_PAREN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCLOSE_PAREN, 0)
}

func (s *Grouping_sets_clauseContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Grouping_sets_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Grouping_sets_clauseContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterGrouping_sets_clause(s)
	}
}

func (s *Grouping_sets_clauseContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitGrouping_sets_clause(s)
	}
}

func (s *Grouping_sets_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitGrouping_sets_clause(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Grouping_sets_clause() (localctx IGrouping_sets_clauseContext) {
	localctx = NewGrouping_sets_clauseContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1036, PostgreSQLParserRULE_grouping_sets_clause)
	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(8213)
		p.Match(PostgreSQLParserGROUPING)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(8214)
		p.Match(PostgreSQLParserSETS)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(8215)
		p.Match(PostgreSQLParserOPEN_PAREN)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(8216)
		p.Group_by_list()
	}
	{
		p.SetState(8217)
		p.Match(PostgreSQLParserCLOSE_PAREN)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IHaving_clauseContext is an interface to support dynamic dispatch.
type IHaving_clauseContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	HAVING() antlr.TerminalNode
	A_expr() IA_exprContext

	// IsHaving_clauseContext differentiates from other interfaces.
	IsHaving_clauseContext()
}

type Having_clauseContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyHaving_clauseContext() *Having_clauseContext {
	var p = new(Having_clauseContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_having_clause
	return p
}

func InitEmptyHaving_clauseContext(p *Having_clauseContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_having_clause
}

func (*Having_clauseContext) IsHaving_clauseContext() {}

func NewHaving_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Having_clauseContext {
	var p = new(Having_clauseContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_having_clause

	return p
}

func (s *Having_clauseContext) GetParser() antlr.Parser { return s.parser }

func (s *Having_clauseContext) HAVING() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserHAVING, 0)
}

func (s *Having_clauseContext) A_expr() IA_exprContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IA_exprContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IA_exprContext)
}

func (s *Having_clauseContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Having_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Having_clauseContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterHaving_clause(s)
	}
}

func (s *Having_clauseContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitHaving_clause(s)
	}
}

func (s *Having_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitHaving_clause(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Having_clause() (localctx IHaving_clauseContext) {
	localctx = NewHaving_clauseContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1038, PostgreSQLParserRULE_having_clause)
	p.SetState(8222)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetTokenStream().LA(1) {
	case PostgreSQLParserHAVING:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(8219)
			p.Match(PostgreSQLParserHAVING)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(8220)
			p.A_expr()
		}

	case PostgreSQLParserEOF, PostgreSQLParserOPEN_PAREN, PostgreSQLParserCLOSE_PAREN, PostgreSQLParserCOMMA, PostgreSQLParserSEMI, PostgreSQLParserANALYSE, PostgreSQLParserANALYZE, PostgreSQLParserCREATE, PostgreSQLParserDO, PostgreSQLParserEXCEPT, PostgreSQLParserFETCH, PostgreSQLParserFOR, PostgreSQLParserGRANT, PostgreSQLParserINTERSECT, PostgreSQLParserINTO, PostgreSQLParserLIMIT, PostgreSQLParserOFFSET, PostgreSQLParserON, PostgreSQLParserORDER, PostgreSQLParserRETURNING, PostgreSQLParserSELECT, PostgreSQLParserTABLE, PostgreSQLParserTHEN, PostgreSQLParserUNION, PostgreSQLParserUSING, PostgreSQLParserWHEN, PostgreSQLParserWINDOW, PostgreSQLParserWITH, PostgreSQLParserABORT_P, PostgreSQLParserALTER, PostgreSQLParserBEGIN_P, PostgreSQLParserCHECKPOINT, PostgreSQLParserCLOSE, PostgreSQLParserCLUSTER, PostgreSQLParserCOMMENT, PostgreSQLParserCOMMIT, PostgreSQLParserCOPY, PostgreSQLParserDEALLOCATE, PostgreSQLParserDECLARE, PostgreSQLParserDELETE_P, PostgreSQLParserDISCARD, PostgreSQLParserDROP, PostgreSQLParserEXECUTE, PostgreSQLParserEXPLAIN, PostgreSQLParserINSERT, PostgreSQLParserLISTEN, PostgreSQLParserLOAD, PostgreSQLParserLOCK_P, PostgreSQLParserMERGE, PostgreSQLParserMOVE, PostgreSQLParserNOTIFY, PostgreSQLParserPREPARE, PostgreSQLParserREASSIGN, PostgreSQLParserREFRESH, PostgreSQLParserREINDEX, PostgreSQLParserRELEASE, PostgreSQLParserRESET, PostgreSQLParserREVOKE, PostgreSQLParserROLLBACK, PostgreSQLParserSAVEPOINT, PostgreSQLParserSECURITY, PostgreSQLParserSET, PostgreSQLParserSHOW, PostgreSQLParserSTART, PostgreSQLParserTRUNCATE, PostgreSQLParserUNLISTEN, PostgreSQLParserUPDATE, PostgreSQLParserVACUUM, PostgreSQLParserVALUES, PostgreSQLParserCALL, PostgreSQLParserIMPORT_P, PostgreSQLParserEND_P, PostgreSQLParserLOOP, PostgreSQLParserMetaCommand:
		p.EnterOuterAlt(localctx, 2)

	default:
		p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IFor_locking_clauseContext is an interface to support dynamic dispatch.
type IFor_locking_clauseContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	For_locking_items() IFor_locking_itemsContext
	FOR() antlr.TerminalNode
	READ() antlr.TerminalNode
	ONLY() antlr.TerminalNode

	// IsFor_locking_clauseContext differentiates from other interfaces.
	IsFor_locking_clauseContext()
}

type For_locking_clauseContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyFor_locking_clauseContext() *For_locking_clauseContext {
	var p = new(For_locking_clauseContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_for_locking_clause
	return p
}

func InitEmptyFor_locking_clauseContext(p *For_locking_clauseContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_for_locking_clause
}

func (*For_locking_clauseContext) IsFor_locking_clauseContext() {}

func NewFor_locking_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *For_locking_clauseContext {
	var p = new(For_locking_clauseContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_for_locking_clause

	return p
}

func (s *For_locking_clauseContext) GetParser() antlr.Parser { return s.parser }

func (s *For_locking_clauseContext) For_locking_items() IFor_locking_itemsContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IFor_locking_itemsContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IFor_locking_itemsContext)
}

func (s *For_locking_clauseContext) FOR() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserFOR, 0)
}

func (s *For_locking_clauseContext) READ() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserREAD, 0)
}

func (s *For_locking_clauseContext) ONLY() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserONLY, 0)
}

func (s *For_locking_clauseContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *For_locking_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *For_locking_clauseContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterFor_locking_clause(s)
	}
}

func (s *For_locking_clauseContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitFor_locking_clause(s)
	}
}

func (s *For_locking_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitFor_locking_clause(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) For_locking_clause() (localctx IFor_locking_clauseContext) {
	localctx = NewFor_locking_clauseContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1040, PostgreSQLParserRULE_for_locking_clause)
	p.SetState(8228)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 458, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(8224)
			p.For_locking_items()
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(8225)
			p.Match(PostgreSQLParserFOR)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(8226)
			p.Match(PostgreSQLParserREAD)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(8227)
			p.Match(PostgreSQLParserONLY)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case antlr.ATNInvalidAltNumber:
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IOpt_for_locking_clauseContext is an interface to support dynamic dispatch.
type IOpt_for_locking_clauseContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	For_locking_clause() IFor_locking_clauseContext

	// IsOpt_for_locking_clauseContext differentiates from other interfaces.
	IsOpt_for_locking_clauseContext()
}

type Opt_for_locking_clauseContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyOpt_for_locking_clauseContext() *Opt_for_locking_clauseContext {
	var p = new(Opt_for_locking_clauseContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opt_for_locking_clause
	return p
}

func InitEmptyOpt_for_locking_clauseContext(p *Opt_for_locking_clauseContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opt_for_locking_clause
}

func (*Opt_for_locking_clauseContext) IsOpt_for_locking_clauseContext() {}

func NewOpt_for_locking_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_for_locking_clauseContext {
	var p = new(Opt_for_locking_clauseContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_opt_for_locking_clause

	return p
}

func (s *Opt_for_locking_clauseContext) GetParser() antlr.Parser { return s.parser }

func (s *Opt_for_locking_clauseContext) For_locking_clause() IFor_locking_clauseContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IFor_locking_clauseContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IFor_locking_clauseContext)
}

func (s *Opt_for_locking_clauseContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Opt_for_locking_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Opt_for_locking_clauseContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterOpt_for_locking_clause(s)
	}
}

func (s *Opt_for_locking_clauseContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitOpt_for_locking_clause(s)
	}
}

func (s *Opt_for_locking_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitOpt_for_locking_clause(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Opt_for_locking_clause() (localctx IOpt_for_locking_clauseContext) {
	localctx = NewOpt_for_locking_clauseContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1042, PostgreSQLParserRULE_opt_for_locking_clause)
	p.SetState(8232)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetTokenStream().LA(1) {
	case PostgreSQLParserFOR:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(8230)
			p.For_locking_clause()
		}

	case PostgreSQLParserEOF, PostgreSQLParserOPEN_PAREN, PostgreSQLParserCLOSE_PAREN, PostgreSQLParserSEMI, PostgreSQLParserANALYSE, PostgreSQLParserANALYZE, PostgreSQLParserCREATE, PostgreSQLParserDO, PostgreSQLParserFETCH, PostgreSQLParserGRANT, PostgreSQLParserINTO, PostgreSQLParserON, PostgreSQLParserRETURNING, PostgreSQLParserSELECT, PostgreSQLParserTABLE, PostgreSQLParserWITH, PostgreSQLParserABORT_P, PostgreSQLParserALTER, PostgreSQLParserBEGIN_P, PostgreSQLParserCHECKPOINT, PostgreSQLParserCLOSE, PostgreSQLParserCLUSTER, PostgreSQLParserCOMMENT, PostgreSQLParserCOMMIT, PostgreSQLParserCOPY, PostgreSQLParserDEALLOCATE, PostgreSQLParserDECLARE, PostgreSQLParserDELETE_P, PostgreSQLParserDISCARD, PostgreSQLParserDROP, PostgreSQLParserEXECUTE, PostgreSQLParserEXPLAIN, PostgreSQLParserINSERT, PostgreSQLParserLISTEN, PostgreSQLParserLOAD, PostgreSQLParserLOCK_P, PostgreSQLParserMERGE, PostgreSQLParserMOVE, PostgreSQLParserNOTIFY, PostgreSQLParserPREPARE, PostgreSQLParserREASSIGN, PostgreSQLParserREFRESH, PostgreSQLParserREINDEX, PostgreSQLParserRELEASE, PostgreSQLParserRESET, PostgreSQLParserREVOKE, PostgreSQLParserROLLBACK, PostgreSQLParserSAVEPOINT, PostgreSQLParserSECURITY, PostgreSQLParserSET, PostgreSQLParserSHOW, PostgreSQLParserSTART, PostgreSQLParserTRUNCATE, PostgreSQLParserUNLISTEN, PostgreSQLParserUPDATE, PostgreSQLParserVACUUM, PostgreSQLParserVALUES, PostgreSQLParserCALL, PostgreSQLParserIMPORT_P, PostgreSQLParserEND_P, PostgreSQLParserLOOP, PostgreSQLParserMetaCommand:
		p.EnterOuterAlt(localctx, 2)

	default:
		p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IFor_locking_itemsContext is an interface to support dynamic dispatch.
type IFor_locking_itemsContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	AllFor_locking_item() []IFor_locking_itemContext
	For_locking_item(i int) IFor_locking_itemContext

	// IsFor_locking_itemsContext differentiates from other interfaces.
	IsFor_locking_itemsContext()
}

type For_locking_itemsContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyFor_locking_itemsContext() *For_locking_itemsContext {
	var p = new(For_locking_itemsContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_for_locking_items
	return p
}

func InitEmptyFor_locking_itemsContext(p *For_locking_itemsContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_for_locking_items
}

func (*For_locking_itemsContext) IsFor_locking_itemsContext() {}

func NewFor_locking_itemsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *For_locking_itemsContext {
	var p = new(For_locking_itemsContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_for_locking_items

	return p
}

func (s *For_locking_itemsContext) GetParser() antlr.Parser { return s.parser }

func (s *For_locking_itemsContext) AllFor_locking_item() []IFor_locking_itemContext {
	children := s.GetChildren()
	len := 0
	for _, ctx := range children {
		if _, ok := ctx.(IFor_locking_itemContext); ok {
			len++
		}
	}

	tst := make([]IFor_locking_itemContext, len)
	i := 0
	for _, ctx := range children {
		if t, ok := ctx.(IFor_locking_itemContext); ok {
			tst[i] = t.(IFor_locking_itemContext)
			i++
		}
	}

	return tst
}

func (s *For_locking_itemsContext) For_locking_item(i int) IFor_locking_itemContext {
	var t antlr.RuleContext
	j := 0
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IFor_locking_itemContext); ok {
			if j == i {
				t = ctx.(antlr.RuleContext)
				break
			}
			j++
		}
	}

	if t == nil {
		return nil
	}

	return t.(IFor_locking_itemContext)
}

func (s *For_locking_itemsContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *For_locking_itemsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *For_locking_itemsContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterFor_locking_items(s)
	}
}

func (s *For_locking_itemsContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitFor_locking_items(s)
	}
}

func (s *For_locking_itemsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitFor_locking_items(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) For_locking_items() (localctx IFor_locking_itemsContext) {
	localctx = NewFor_locking_itemsContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1044, PostgreSQLParserRULE_for_locking_items)
	var _la int

	p.EnterOuterAlt(localctx, 1)
	p.SetState(8235)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}
	_la = p.GetTokenStream().LA(1)

	for ok := true; ok; ok = _la == PostgreSQLParserFOR {
		{
			p.SetState(8234)
			p.For_locking_item()
		}

		p.SetState(8237)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}
		_la = p.GetTokenStream().LA(1)
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IFor_locking_itemContext is an interface to support dynamic dispatch.
type IFor_locking_itemContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	For_locking_strength() IFor_locking_strengthContext
	Locked_rels_list() ILocked_rels_listContext
	Opt_nowait_or_skip() IOpt_nowait_or_skipContext

	// IsFor_locking_itemContext differentiates from other interfaces.
	IsFor_locking_itemContext()
}

type For_locking_itemContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyFor_locking_itemContext() *For_locking_itemContext {
	var p = new(For_locking_itemContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_for_locking_item
	return p
}

func InitEmptyFor_locking_itemContext(p *For_locking_itemContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_for_locking_item
}

func (*For_locking_itemContext) IsFor_locking_itemContext() {}

func NewFor_locking_itemContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *For_locking_itemContext {
	var p = new(For_locking_itemContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_for_locking_item

	return p
}

func (s *For_locking_itemContext) GetParser() antlr.Parser { return s.parser }

func (s *For_locking_itemContext) For_locking_strength() IFor_locking_strengthContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IFor_locking_strengthContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IFor_locking_strengthContext)
}

func (s *For_locking_itemContext) Locked_rels_list() ILocked_rels_listContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ILocked_rels_listContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ILocked_rels_listContext)
}

func (s *For_locking_itemContext) Opt_nowait_or_skip() IOpt_nowait_or_skipContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOpt_nowait_or_skipContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOpt_nowait_or_skipContext)
}

func (s *For_locking_itemContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *For_locking_itemContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *For_locking_itemContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterFor_locking_item(s)
	}
}

func (s *For_locking_itemContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitFor_locking_item(s)
	}
}

func (s *For_locking_itemContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitFor_locking_item(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) For_locking_item() (localctx IFor_locking_itemContext) {
	localctx = NewFor_locking_itemContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1046, PostgreSQLParserRULE_for_locking_item)
	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(8239)
		p.For_locking_strength()
	}
	{
		p.SetState(8240)
		p.Locked_rels_list()
	}
	{
		p.SetState(8241)
		p.Opt_nowait_or_skip()
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IFor_locking_strengthContext is an interface to support dynamic dispatch.
type IFor_locking_strengthContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	FOR() antlr.TerminalNode
	UPDATE() antlr.TerminalNode
	SHARE() antlr.TerminalNode
	NO() antlr.TerminalNode
	KEY() antlr.TerminalNode

	// IsFor_locking_strengthContext differentiates from other interfaces.
	IsFor_locking_strengthContext()
}

type For_locking_strengthContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyFor_locking_strengthContext() *For_locking_strengthContext {
	var p = new(For_locking_strengthContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_for_locking_strength
	return p
}

func InitEmptyFor_locking_strengthContext(p *For_locking_strengthContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_for_locking_strength
}

func (*For_locking_strengthContext) IsFor_locking_strengthContext() {}

func NewFor_locking_strengthContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *For_locking_strengthContext {
	var p = new(For_locking_strengthContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_for_locking_strength

	return p
}

func (s *For_locking_strengthContext) GetParser() antlr.Parser { return s.parser }

func (s *For_locking_strengthContext) FOR() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserFOR, 0)
}

func (s *For_locking_strengthContext) UPDATE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserUPDATE, 0)
}

func (s *For_locking_strengthContext) SHARE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserSHARE, 0)
}

func (s *For_locking_strengthContext) NO() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserNO, 0)
}

func (s *For_locking_strengthContext) KEY() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserKEY, 0)
}

func (s *For_locking_strengthContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *For_locking_strengthContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *For_locking_strengthContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterFor_locking_strength(s)
	}
}

func (s *For_locking_strengthContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitFor_locking_strength(s)
	}
}

func (s *For_locking_strengthContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitFor_locking_strength(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) For_locking_strength() (localctx IFor_locking_strengthContext) {
	localctx = NewFor_locking_strengthContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1048, PostgreSQLParserRULE_for_locking_strength)
	var _la int

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(8243)
		p.Match(PostgreSQLParserFOR)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	p.SetState(8253)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetTokenStream().LA(1) {
	case PostgreSQLParserNO, PostgreSQLParserUPDATE:
		p.SetState(8246)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}
		_la = p.GetTokenStream().LA(1)

		if _la == PostgreSQLParserNO {
			{
				p.SetState(8244)
				p.Match(PostgreSQLParserNO)
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}
			{
				p.SetState(8245)
				p.Match(PostgreSQLParserKEY)
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}

		}
		{
			p.SetState(8248)
			p.Match(PostgreSQLParserUPDATE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case PostgreSQLParserKEY, PostgreSQLParserSHARE:
		p.SetState(8250)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}
		_la = p.GetTokenStream().LA(1)

		if _la == PostgreSQLParserKEY {
			{
				p.SetState(8249)
				p.Match(PostgreSQLParserKEY)
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}

		}
		{
			p.SetState(8252)
			p.Match(PostgreSQLParserSHARE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	default:
		p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// ILocked_rels_listContext is an interface to support dynamic dispatch.
type ILocked_rels_listContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	OF() antlr.TerminalNode
	Qualified_name_list() IQualified_name_listContext

	// IsLocked_rels_listContext differentiates from other interfaces.
	IsLocked_rels_listContext()
}

type Locked_rels_listContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyLocked_rels_listContext() *Locked_rels_listContext {
	var p = new(Locked_rels_listContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_locked_rels_list
	return p
}

func InitEmptyLocked_rels_listContext(p *Locked_rels_listContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_locked_rels_list
}

func (*Locked_rels_listContext) IsLocked_rels_listContext() {}

func NewLocked_rels_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Locked_rels_listContext {
	var p = new(Locked_rels_listContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_locked_rels_list

	return p
}

func (s *Locked_rels_listContext) GetParser() antlr.Parser { return s.parser }

func (s *Locked_rels_listContext) OF() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserOF, 0)
}

func (s *Locked_rels_listContext) Qualified_name_list() IQualified_name_listContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IQualified_name_listContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IQualified_name_listContext)
}

func (s *Locked_rels_listContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Locked_rels_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Locked_rels_listContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterLocked_rels_list(s)
	}
}

func (s *Locked_rels_listContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitLocked_rels_list(s)
	}
}

func (s *Locked_rels_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitLocked_rels_list(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Locked_rels_list() (localctx ILocked_rels_listContext) {
	localctx = NewLocked_rels_listContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1050, PostgreSQLParserRULE_locked_rels_list)
	p.SetState(8258)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetTokenStream().LA(1) {
	case PostgreSQLParserOF:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(8255)
			p.Match(PostgreSQLParserOF)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(8256)
			p.Qualified_name_list()
		}

	case PostgreSQLParserEOF, PostgreSQLParserOPEN_PAREN, PostgreSQLParserCLOSE_PAREN, PostgreSQLParserSEMI, PostgreSQLParserANALYSE, PostgreSQLParserANALYZE, PostgreSQLParserCREATE, PostgreSQLParserDO, PostgreSQLParserFETCH, PostgreSQLParserFOR, PostgreSQLParserGRANT, PostgreSQLParserINTO, PostgreSQLParserLIMIT, PostgreSQLParserOFFSET, PostgreSQLParserON, PostgreSQLParserRETURNING, PostgreSQLParserSELECT, PostgreSQLParserTABLE, PostgreSQLParserWITH, PostgreSQLParserABORT_P, PostgreSQLParserALTER, PostgreSQLParserBEGIN_P, PostgreSQLParserCHECKPOINT, PostgreSQLParserCLOSE, PostgreSQLParserCLUSTER, PostgreSQLParserCOMMENT, PostgreSQLParserCOMMIT, PostgreSQLParserCOPY, PostgreSQLParserDEALLOCATE, PostgreSQLParserDECLARE, PostgreSQLParserDELETE_P, PostgreSQLParserDISCARD, PostgreSQLParserDROP, PostgreSQLParserEXECUTE, PostgreSQLParserEXPLAIN, PostgreSQLParserINSERT, PostgreSQLParserLISTEN, PostgreSQLParserLOAD, PostgreSQLParserLOCK_P, PostgreSQLParserMERGE, PostgreSQLParserMOVE, PostgreSQLParserNOTIFY, PostgreSQLParserNOWAIT, PostgreSQLParserPREPARE, PostgreSQLParserREASSIGN, PostgreSQLParserREFRESH, PostgreSQLParserREINDEX, PostgreSQLParserRELEASE, PostgreSQLParserRESET, PostgreSQLParserREVOKE, PostgreSQLParserROLLBACK, PostgreSQLParserSAVEPOINT, PostgreSQLParserSECURITY, PostgreSQLParserSET, PostgreSQLParserSHOW, PostgreSQLParserSTART, PostgreSQLParserTRUNCATE, PostgreSQLParserUNLISTEN, PostgreSQLParserUPDATE, PostgreSQLParserVACUUM, PostgreSQLParserVALUES, PostgreSQLParserCALL, PostgreSQLParserIMPORT_P, PostgreSQLParserEND_P, PostgreSQLParserSKIP_P, PostgreSQLParserLOOP, PostgreSQLParserMetaCommand:
		p.EnterOuterAlt(localctx, 2)

	default:
		p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IValues_clauseContext is an interface to support dynamic dispatch.
type IValues_clauseContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	VALUES() antlr.TerminalNode
	AllOPEN_PAREN() []antlr.TerminalNode
	OPEN_PAREN(i int) antlr.TerminalNode
	AllExpr_list() []IExpr_listContext
	Expr_list(i int) IExpr_listContext
	AllCLOSE_PAREN() []antlr.TerminalNode
	CLOSE_PAREN(i int) antlr.TerminalNode
	AllCOMMA() []antlr.TerminalNode
	COMMA(i int) antlr.TerminalNode

	// IsValues_clauseContext differentiates from other interfaces.
	IsValues_clauseContext()
}

type Values_clauseContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyValues_clauseContext() *Values_clauseContext {
	var p = new(Values_clauseContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_values_clause
	return p
}

func InitEmptyValues_clauseContext(p *Values_clauseContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_values_clause
}

func (*Values_clauseContext) IsValues_clauseContext() {}

func NewValues_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Values_clauseContext {
	var p = new(Values_clauseContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_values_clause

	return p
}

func (s *Values_clauseContext) GetParser() antlr.Parser { return s.parser }

func (s *Values_clauseContext) VALUES() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserVALUES, 0)
}

func (s *Values_clauseContext) AllOPEN_PAREN() []antlr.TerminalNode {
	return s.GetTokens(PostgreSQLParserOPEN_PAREN)
}

func (s *Values_clauseContext) OPEN_PAREN(i int) antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserOPEN_PAREN, i)
}

func (s *Values_clauseContext) AllExpr_list() []IExpr_listContext {
	children := s.GetChildren()
	len := 0
	for _, ctx := range children {
		if _, ok := ctx.(IExpr_listContext); ok {
			len++
		}
	}

	tst := make([]IExpr_listContext, len)
	i := 0
	for _, ctx := range children {
		if t, ok := ctx.(IExpr_listContext); ok {
			tst[i] = t.(IExpr_listContext)
			i++
		}
	}

	return tst
}

func (s *Values_clauseContext) Expr_list(i int) IExpr_listContext {
	var t antlr.RuleContext
	j := 0
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IExpr_listContext); ok {
			if j == i {
				t = ctx.(antlr.RuleContext)
				break
			}
			j++
		}
	}

	if t == nil {
		return nil
	}

	return t.(IExpr_listContext)
}

func (s *Values_clauseContext) AllCLOSE_PAREN() []antlr.TerminalNode {
	return s.GetTokens(PostgreSQLParserCLOSE_PAREN)
}

func (s *Values_clauseContext) CLOSE_PAREN(i int) antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCLOSE_PAREN, i)
}

func (s *Values_clauseContext) AllCOMMA() []antlr.TerminalNode {
	return s.GetTokens(PostgreSQLParserCOMMA)
}

func (s *Values_clauseContext) COMMA(i int) antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCOMMA, i)
}

func (s *Values_clauseContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Values_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Values_clauseContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterValues_clause(s)
	}
}

func (s *Values_clauseContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitValues_clause(s)
	}
}

func (s *Values_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitValues_clause(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Values_clause() (localctx IValues_clauseContext) {
	localctx = NewValues_clauseContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1052, PostgreSQLParserRULE_values_clause)
	var _la int

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(8260)
		p.Match(PostgreSQLParserVALUES)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(8261)
		p.Match(PostgreSQLParserOPEN_PAREN)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(8262)
		p.Expr_list()
	}
	{
		p.SetState(8263)
		p.Match(PostgreSQLParserCLOSE_PAREN)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	p.SetState(8271)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}
	_la = p.GetTokenStream().LA(1)

	for _la == PostgreSQLParserCOMMA {
		{
			p.SetState(8264)
			p.Match(PostgreSQLParserCOMMA)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(8265)
			p.Match(PostgreSQLParserOPEN_PAREN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(8266)
			p.Expr_list()
		}
		{
			p.SetState(8267)
			p.Match(PostgreSQLParserCLOSE_PAREN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

		p.SetState(8273)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}
		_la = p.GetTokenStream().LA(1)
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IFrom_clauseContext is an interface to support dynamic dispatch.
type IFrom_clauseContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	FROM() antlr.TerminalNode
	From_list() IFrom_listContext

	// IsFrom_clauseContext differentiates from other interfaces.
	IsFrom_clauseContext()
}

type From_clauseContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyFrom_clauseContext() *From_clauseContext {
	var p = new(From_clauseContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_from_clause
	return p
}

func InitEmptyFrom_clauseContext(p *From_clauseContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_from_clause
}

func (*From_clauseContext) IsFrom_clauseContext() {}

func NewFrom_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *From_clauseContext {
	var p = new(From_clauseContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_from_clause

	return p
}

func (s *From_clauseContext) GetParser() antlr.Parser { return s.parser }

func (s *From_clauseContext) FROM() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserFROM, 0)
}

func (s *From_clauseContext) From_list() IFrom_listContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IFrom_listContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IFrom_listContext)
}

func (s *From_clauseContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *From_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *From_clauseContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterFrom_clause(s)
	}
}

func (s *From_clauseContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitFrom_clause(s)
	}
}

func (s *From_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitFrom_clause(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) From_clause() (localctx IFrom_clauseContext) {
	localctx = NewFrom_clauseContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1054, PostgreSQLParserRULE_from_clause)
	p.SetState(8277)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetTokenStream().LA(1) {
	case PostgreSQLParserFROM:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(8274)
			p.Match(PostgreSQLParserFROM)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(8275)
			p.From_list()
		}

	case PostgreSQLParserEOF, PostgreSQLParserOPEN_PAREN, PostgreSQLParserCLOSE_PAREN, PostgreSQLParserCOMMA, PostgreSQLParserSEMI, PostgreSQLParserANALYSE, PostgreSQLParserANALYZE, PostgreSQLParserCREATE, PostgreSQLParserDO, PostgreSQLParserEXCEPT, PostgreSQLParserFETCH, PostgreSQLParserFOR, PostgreSQLParserGRANT, PostgreSQLParserGROUP_P, PostgreSQLParserHAVING, PostgreSQLParserINTERSECT, PostgreSQLParserINTO, PostgreSQLParserLIMIT, PostgreSQLParserOFFSET, PostgreSQLParserON, PostgreSQLParserORDER, PostgreSQLParserRETURNING, PostgreSQLParserSELECT, PostgreSQLParserTABLE, PostgreSQLParserTHEN, PostgreSQLParserUNION, PostgreSQLParserUSING, PostgreSQLParserWHEN, PostgreSQLParserWHERE, PostgreSQLParserWINDOW, PostgreSQLParserWITH, PostgreSQLParserABORT_P, PostgreSQLParserALTER, PostgreSQLParserBEGIN_P, PostgreSQLParserCHECKPOINT, PostgreSQLParserCLOSE, PostgreSQLParserCLUSTER, PostgreSQLParserCOMMENT, PostgreSQLParserCOMMIT, PostgreSQLParserCOPY, PostgreSQLParserDEALLOCATE, PostgreSQLParserDECLARE, PostgreSQLParserDELETE_P, PostgreSQLParserDISCARD, PostgreSQLParserDROP, PostgreSQLParserEXECUTE, PostgreSQLParserEXPLAIN, PostgreSQLParserINSERT, PostgreSQLParserLISTEN, PostgreSQLParserLOAD, PostgreSQLParserLOCK_P, PostgreSQLParserMERGE, PostgreSQLParserMOVE, PostgreSQLParserNOTIFY, PostgreSQLParserPREPARE, PostgreSQLParserREASSIGN, PostgreSQLParserREFRESH, PostgreSQLParserREINDEX, PostgreSQLParserRELEASE, PostgreSQLParserRESET, PostgreSQLParserREVOKE, PostgreSQLParserROLLBACK, PostgreSQLParserSAVEPOINT, PostgreSQLParserSECURITY, PostgreSQLParserSET, PostgreSQLParserSHOW, PostgreSQLParserSTART, PostgreSQLParserTRUNCATE, PostgreSQLParserUNLISTEN, PostgreSQLParserUPDATE, PostgreSQLParserVACUUM, PostgreSQLParserVALUES, PostgreSQLParserCALL, PostgreSQLParserIMPORT_P, PostgreSQLParserEND_P, PostgreSQLParserLOOP, PostgreSQLParserMetaCommand:
		p.EnterOuterAlt(localctx, 2)

	default:
		p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IFrom_listContext is an interface to support dynamic dispatch.
type IFrom_listContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Non_ansi_join() INon_ansi_joinContext
	AllTable_ref() []ITable_refContext
	Table_ref(i int) ITable_refContext
	AllCOMMA() []antlr.TerminalNode
	COMMA(i int) antlr.TerminalNode

	// IsFrom_listContext differentiates from other interfaces.
	IsFrom_listContext()
}

type From_listContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyFrom_listContext() *From_listContext {
	var p = new(From_listContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_from_list
	return p
}

func InitEmptyFrom_listContext(p *From_listContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_from_list
}

func (*From_listContext) IsFrom_listContext() {}

func NewFrom_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *From_listContext {
	var p = new(From_listContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_from_list

	return p
}

func (s *From_listContext) GetParser() antlr.Parser { return s.parser }

func (s *From_listContext) Non_ansi_join() INon_ansi_joinContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(INon_ansi_joinContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(INon_ansi_joinContext)
}

func (s *From_listContext) AllTable_ref() []ITable_refContext {
	children := s.GetChildren()
	len := 0
	for _, ctx := range children {
		if _, ok := ctx.(ITable_refContext); ok {
			len++
		}
	}

	tst := make([]ITable_refContext, len)
	i := 0
	for _, ctx := range children {
		if t, ok := ctx.(ITable_refContext); ok {
			tst[i] = t.(ITable_refContext)
			i++
		}
	}

	return tst
}

func (s *From_listContext) Table_ref(i int) ITable_refContext {
	var t antlr.RuleContext
	j := 0
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ITable_refContext); ok {
			if j == i {
				t = ctx.(antlr.RuleContext)
				break
			}
			j++
		}
	}

	if t == nil {
		return nil
	}

	return t.(ITable_refContext)
}

func (s *From_listContext) AllCOMMA() []antlr.TerminalNode {
	return s.GetTokens(PostgreSQLParserCOMMA)
}

func (s *From_listContext) COMMA(i int) antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCOMMA, i)
}

func (s *From_listContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *From_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *From_listContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterFrom_list(s)
	}
}

func (s *From_listContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitFrom_list(s)
	}
}

func (s *From_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitFrom_list(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) From_list() (localctx IFrom_listContext) {
	localctx = NewFrom_listContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1056, PostgreSQLParserRULE_from_list)
	var _alt int

	p.SetState(8288)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 468, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(8279)
			p.Non_ansi_join()
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(8280)
			p.Table_ref()
		}
		p.SetState(8285)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}
		_alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 467, p.GetParserRuleContext())
		if p.HasError() {
			goto errorExit
		}
		for _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
			if _alt == 1 {
				{
					p.SetState(8281)
					p.Match(PostgreSQLParserCOMMA)
					if p.HasError() {
						// Recognition error - abort rule
						goto errorExit
					}
				}
				{
					p.SetState(8282)
					p.Table_ref()
				}

			}
			p.SetState(8287)
			p.GetErrorHandler().Sync(p)
			if p.HasError() {
				goto errorExit
			}
			_alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 467, p.GetParserRuleContext())
			if p.HasError() {
				goto errorExit
			}
		}

	case antlr.ATNInvalidAltNumber:
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// INon_ansi_joinContext is an interface to support dynamic dispatch.
type INon_ansi_joinContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	AllTable_ref() []ITable_refContext
	Table_ref(i int) ITable_refContext
	AllCOMMA() []antlr.TerminalNode
	COMMA(i int) antlr.TerminalNode

	// IsNon_ansi_joinContext differentiates from other interfaces.
	IsNon_ansi_joinContext()
}

type Non_ansi_joinContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyNon_ansi_joinContext() *Non_ansi_joinContext {
	var p = new(Non_ansi_joinContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_non_ansi_join
	return p
}

func InitEmptyNon_ansi_joinContext(p *Non_ansi_joinContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_non_ansi_join
}

func (*Non_ansi_joinContext) IsNon_ansi_joinContext() {}

func NewNon_ansi_joinContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Non_ansi_joinContext {
	var p = new(Non_ansi_joinContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_non_ansi_join

	return p
}

func (s *Non_ansi_joinContext) GetParser() antlr.Parser { return s.parser }

func (s *Non_ansi_joinContext) AllTable_ref() []ITable_refContext {
	children := s.GetChildren()
	len := 0
	for _, ctx := range children {
		if _, ok := ctx.(ITable_refContext); ok {
			len++
		}
	}

	tst := make([]ITable_refContext, len)
	i := 0
	for _, ctx := range children {
		if t, ok := ctx.(ITable_refContext); ok {
			tst[i] = t.(ITable_refContext)
			i++
		}
	}

	return tst
}

func (s *Non_ansi_joinContext) Table_ref(i int) ITable_refContext {
	var t antlr.RuleContext
	j := 0
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ITable_refContext); ok {
			if j == i {
				t = ctx.(antlr.RuleContext)
				break
			}
			j++
		}
	}

	if t == nil {
		return nil
	}

	return t.(ITable_refContext)
}

func (s *Non_ansi_joinContext) AllCOMMA() []antlr.TerminalNode {
	return s.GetTokens(PostgreSQLParserCOMMA)
}

func (s *Non_ansi_joinContext) COMMA(i int) antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCOMMA, i)
}

func (s *Non_ansi_joinContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Non_ansi_joinContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Non_ansi_joinContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterNon_ansi_join(s)
	}
}

func (s *Non_ansi_joinContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitNon_ansi_join(s)
	}
}

func (s *Non_ansi_joinContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitNon_ansi_join(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Non_ansi_join() (localctx INon_ansi_joinContext) {
	localctx = NewNon_ansi_joinContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1058, PostgreSQLParserRULE_non_ansi_join)
	var _alt int

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(8290)
		p.Table_ref()
	}
	p.SetState(8293)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}
	_alt = 1
	for ok := true; ok; ok = _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
		switch _alt {
		case 1:
			{
				p.SetState(8291)
				p.Match(PostgreSQLParserCOMMA)
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}
			{
				p.SetState(8292)
				p.Table_ref()
			}

		default:
			p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
			goto errorExit
		}

		p.SetState(8295)
		p.GetErrorHandler().Sync(p)
		_alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 469, p.GetParserRuleContext())
		if p.HasError() {
			goto errorExit
		}
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// ITable_refContext is an interface to support dynamic dispatch.
type ITable_refContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Relation_expr() IRelation_exprContext
	Opt_alias_clause() IOpt_alias_clauseContext
	Func_table() IFunc_tableContext
	Func_alias_clause() IFunc_alias_clauseContext
	Xmltable() IXmltableContext
	Select_with_parens() ISelect_with_parensContext
	LATERAL_P() antlr.TerminalNode
	OPEN_PAREN() antlr.TerminalNode
	AllTable_ref() []ITable_refContext
	Table_ref(i int) ITable_refContext
	CLOSE_PAREN() antlr.TerminalNode
	AllCROSS() []antlr.TerminalNode
	CROSS(i int) antlr.TerminalNode
	AllJOIN() []antlr.TerminalNode
	JOIN(i int) antlr.TerminalNode
	AllNATURAL() []antlr.TerminalNode
	NATURAL(i int) antlr.TerminalNode
	AllJoin_qual() []IJoin_qualContext
	Join_qual(i int) IJoin_qualContext
	Tablesample_clause() ITablesample_clauseContext
	AllJoin_type() []IJoin_typeContext
	Join_type(i int) IJoin_typeContext

	// IsTable_refContext differentiates from other interfaces.
	IsTable_refContext()
}

type Table_refContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyTable_refContext() *Table_refContext {
	var p = new(Table_refContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_table_ref
	return p
}

func InitEmptyTable_refContext(p *Table_refContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_table_ref
}

func (*Table_refContext) IsTable_refContext() {}

func NewTable_refContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Table_refContext {
	var p = new(Table_refContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_table_ref

	return p
}

func (s *Table_refContext) GetParser() antlr.Parser { return s.parser }

func (s *Table_refContext) Relation_expr() IRelation_exprContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IRelation_exprContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IRelation_exprContext)
}

func (s *Table_refContext) Opt_alias_clause() IOpt_alias_clauseContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOpt_alias_clauseContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOpt_alias_clauseContext)
}

func (s *Table_refContext) Func_table() IFunc_tableContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IFunc_tableContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IFunc_tableContext)
}

func (s *Table_refContext) Func_alias_clause() IFunc_alias_clauseContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IFunc_alias_clauseContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IFunc_alias_clauseContext)
}

func (s *Table_refContext) Xmltable() IXmltableContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IXmltableContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IXmltableContext)
}

func (s *Table_refContext) Select_with_parens() ISelect_with_parensContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ISelect_with_parensContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ISelect_with_parensContext)
}

func (s *Table_refContext) LATERAL_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserLATERAL_P, 0)
}

func (s *Table_refContext) OPEN_PAREN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserOPEN_PAREN, 0)
}

func (s *Table_refContext) AllTable_ref() []ITable_refContext {
	children := s.GetChildren()
	len := 0
	for _, ctx := range children {
		if _, ok := ctx.(ITable_refContext); ok {
			len++
		}
	}

	tst := make([]ITable_refContext, len)
	i := 0
	for _, ctx := range children {
		if t, ok := ctx.(ITable_refContext); ok {
			tst[i] = t.(ITable_refContext)
			i++
		}
	}

	return tst
}

func (s *Table_refContext) Table_ref(i int) ITable_refContext {
	var t antlr.RuleContext
	j := 0
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ITable_refContext); ok {
			if j == i {
				t = ctx.(antlr.RuleContext)
				break
			}
			j++
		}
	}

	if t == nil {
		return nil
	}

	return t.(ITable_refContext)
}

func (s *Table_refContext) CLOSE_PAREN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCLOSE_PAREN, 0)
}

func (s *Table_refContext) AllCROSS() []antlr.TerminalNode {
	return s.GetTokens(PostgreSQLParserCROSS)
}

func (s *Table_refContext) CROSS(i int) antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCROSS, i)
}

func (s *Table_refContext) AllJOIN() []antlr.TerminalNode {
	return s.GetTokens(PostgreSQLParserJOIN)
}

func (s *Table_refContext) JOIN(i int) antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserJOIN, i)
}

func (s *Table_refContext) AllNATURAL() []antlr.TerminalNode {
	return s.GetTokens(PostgreSQLParserNATURAL)
}

func (s *Table_refContext) NATURAL(i int) antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserNATURAL, i)
}

func (s *Table_refContext) AllJoin_qual() []IJoin_qualContext {
	children := s.GetChildren()
	len := 0
	for _, ctx := range children {
		if _, ok := ctx.(IJoin_qualContext); ok {
			len++
		}
	}

	tst := make([]IJoin_qualContext, len)
	i := 0
	for _, ctx := range children {
		if t, ok := ctx.(IJoin_qualContext); ok {
			tst[i] = t.(IJoin_qualContext)
			i++
		}
	}

	return tst
}

func (s *Table_refContext) Join_qual(i int) IJoin_qualContext {
	var t antlr.RuleContext
	j := 0
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IJoin_qualContext); ok {
			if j == i {
				t = ctx.(antlr.RuleContext)
				break
			}
			j++
		}
	}

	if t == nil {
		return nil
	}

	return t.(IJoin_qualContext)
}

func (s *Table_refContext) Tablesample_clause() ITablesample_clauseContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ITablesample_clauseContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ITablesample_clauseContext)
}

func (s *Table_refContext) AllJoin_type() []IJoin_typeContext {
	children := s.GetChildren()
	len := 0
	for _, ctx := range children {
		if _, ok := ctx.(IJoin_typeContext); ok {
			len++
		}
	}

	tst := make([]IJoin_typeContext, len)
	i := 0
	for _, ctx := range children {
		if t, ok := ctx.(IJoin_typeContext); ok {
			tst[i] = t.(IJoin_typeContext)
			i++
		}
	}

	return tst
}

func (s *Table_refContext) Join_type(i int) IJoin_typeContext {
	var t antlr.RuleContext
	j := 0
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IJoin_typeContext); ok {
			if j == i {
				t = ctx.(antlr.RuleContext)
				break
			}
			j++
		}
	}

	if t == nil {
		return nil
	}

	return t.(IJoin_typeContext)
}

func (s *Table_refContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Table_refContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Table_refContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterTable_ref(s)
	}
}

func (s *Table_refContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitTable_ref(s)
	}
}

func (s *Table_refContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitTable_ref(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Table_ref() (localctx ITable_refContext) {
	localctx = NewTable_refContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1060, PostgreSQLParserRULE_table_ref)
	var _la int

	var _alt int

	p.EnterOuterAlt(localctx, 1)
	p.SetState(8346)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 475, p.GetParserRuleContext()) {
	case 1:
		{
			p.SetState(8297)
			p.Relation_expr()
		}
		{
			p.SetState(8298)
			p.Opt_alias_clause()
		}
		p.SetState(8300)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}
		_la = p.GetTokenStream().LA(1)

		if _la == PostgreSQLParserTABLESAMPLE {
			{
				p.SetState(8299)
				p.Tablesample_clause()
			}

		}

	case 2:
		{
			p.SetState(8302)
			p.Func_table()
		}
		{
			p.SetState(8303)
			p.Func_alias_clause()
		}

	case 3:
		{
			p.SetState(8305)
			p.Xmltable()
		}
		{
			p.SetState(8306)
			p.Opt_alias_clause()
		}

	case 4:
		{
			p.SetState(8308)
			p.Select_with_parens()
		}
		{
			p.SetState(8309)
			p.Opt_alias_clause()
		}

	case 5:
		{
			p.SetState(8311)
			p.Match(PostgreSQLParserLATERAL_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		p.SetState(8321)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}

		switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 471, p.GetParserRuleContext()) {
		case 1:
			{
				p.SetState(8312)
				p.Xmltable()
			}
			{
				p.SetState(8313)
				p.Opt_alias_clause()
			}

		case 2:
			{
				p.SetState(8315)
				p.Func_table()
			}
			{
				p.SetState(8316)
				p.Func_alias_clause()
			}

		case 3:
			{
				p.SetState(8318)
				p.Select_with_parens()
			}
			{
				p.SetState(8319)
				p.Opt_alias_clause()
			}

		case antlr.ATNInvalidAltNumber:
			goto errorExit
		}

	case 6:
		{
			p.SetState(8323)
			p.Match(PostgreSQLParserOPEN_PAREN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(8324)
			p.Table_ref()
		}
		p.SetState(8341)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}
		switch p.GetTokenStream().LA(1) {
		case PostgreSQLParserCROSS:
			{
				p.SetState(8325)
				p.Match(PostgreSQLParserCROSS)
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}
			{
				p.SetState(8326)
				p.Match(PostgreSQLParserJOIN)
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}
			{
				p.SetState(8327)
				p.Table_ref()
			}

		case PostgreSQLParserNATURAL:
			{
				p.SetState(8328)
				p.Match(PostgreSQLParserNATURAL)
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}
			p.SetState(8330)
			p.GetErrorHandler().Sync(p)
			if p.HasError() {
				goto errorExit
			}
			_la = p.GetTokenStream().LA(1)

			if (int64((_la-113)) & ^0x3f) == 0 && ((int64(1)<<(_la-113))&8261) != 0 {
				{
					p.SetState(8329)
					p.Join_type()
				}

			}
			{
				p.SetState(8332)
				p.Match(PostgreSQLParserJOIN)
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}
			{
				p.SetState(8333)
				p.Table_ref()
			}

		case PostgreSQLParserFULL, PostgreSQLParserINNER_P, PostgreSQLParserJOIN, PostgreSQLParserLEFT, PostgreSQLParserRIGHT:
			p.SetState(8335)
			p.GetErrorHandler().Sync(p)
			if p.HasError() {
				goto errorExit
			}
			_la = p.GetTokenStream().LA(1)

			if (int64((_la-113)) & ^0x3f) == 0 && ((int64(1)<<(_la-113))&8261) != 0 {
				{
					p.SetState(8334)
					p.Join_type()
				}

			}
			{
				p.SetState(8337)
				p.Match(PostgreSQLParserJOIN)
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}
			{
				p.SetState(8338)
				p.Table_ref()
			}
			{
				p.SetState(8339)
				p.Join_qual()
			}

		case PostgreSQLParserCLOSE_PAREN:

		default:
		}
		{
			p.SetState(8343)
			p.Match(PostgreSQLParserCLOSE_PAREN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(8344)
			p.Opt_alias_clause()
		}

	case antlr.ATNInvalidAltNumber:
		goto errorExit
	}
	p.SetState(8366)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}
	_alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 479, p.GetParserRuleContext())
	if p.HasError() {
		goto errorExit
	}
	for _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
		if _alt == 1 {
			p.SetState(8364)
			p.GetErrorHandler().Sync(p)
			if p.HasError() {
				goto errorExit
			}

			switch p.GetTokenStream().LA(1) {
			case PostgreSQLParserCROSS:
				{
					p.SetState(8348)
					p.Match(PostgreSQLParserCROSS)
					if p.HasError() {
						// Recognition error - abort rule
						goto errorExit
					}
				}
				{
					p.SetState(8349)
					p.Match(PostgreSQLParserJOIN)
					if p.HasError() {
						// Recognition error - abort rule
						goto errorExit
					}
				}
				{
					p.SetState(8350)
					p.Table_ref()
				}

			case PostgreSQLParserNATURAL:
				{
					p.SetState(8351)
					p.Match(PostgreSQLParserNATURAL)
					if p.HasError() {
						// Recognition error - abort rule
						goto errorExit
					}
				}
				p.SetState(8353)
				p.GetErrorHandler().Sync(p)
				if p.HasError() {
					goto errorExit
				}
				_la = p.GetTokenStream().LA(1)

				if (int64((_la-113)) & ^0x3f) == 0 && ((int64(1)<<(_la-113))&8261) != 0 {
					{
						p.SetState(8352)
						p.Join_type()
					}

				}
				{
					p.SetState(8355)
					p.Match(PostgreSQLParserJOIN)
					if p.HasError() {
						// Recognition error - abort rule
						goto errorExit
					}
				}
				{
					p.SetState(8356)
					p.Table_ref()
				}

			case PostgreSQLParserFULL, PostgreSQLParserINNER_P, PostgreSQLParserJOIN, PostgreSQLParserLEFT, PostgreSQLParserRIGHT:
				p.SetState(8358)
				p.GetErrorHandler().Sync(p)
				if p.HasError() {
					goto errorExit
				}
				_la = p.GetTokenStream().LA(1)

				if (int64((_la-113)) & ^0x3f) == 0 && ((int64(1)<<(_la-113))&8261) != 0 {
					{
						p.SetState(8357)
						p.Join_type()
					}

				}
				{
					p.SetState(8360)
					p.Match(PostgreSQLParserJOIN)
					if p.HasError() {
						// Recognition error - abort rule
						goto errorExit
					}
				}
				{
					p.SetState(8361)
					p.Table_ref()
				}
				{
					p.SetState(8362)
					p.Join_qual()
				}

			default:
				p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
				goto errorExit
			}

		}
		p.SetState(8368)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}
		_alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 479, p.GetParserRuleContext())
		if p.HasError() {
			goto errorExit
		}
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IAlias_clauseContext is an interface to support dynamic dispatch.
type IAlias_clauseContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Colid() IColidContext
	AS() antlr.TerminalNode
	OPEN_PAREN() antlr.TerminalNode
	Name_list() IName_listContext
	CLOSE_PAREN() antlr.TerminalNode

	// IsAlias_clauseContext differentiates from other interfaces.
	IsAlias_clauseContext()
}

type Alias_clauseContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyAlias_clauseContext() *Alias_clauseContext {
	var p = new(Alias_clauseContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_alias_clause
	return p
}

func InitEmptyAlias_clauseContext(p *Alias_clauseContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_alias_clause
}

func (*Alias_clauseContext) IsAlias_clauseContext() {}

func NewAlias_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alias_clauseContext {
	var p = new(Alias_clauseContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_alias_clause

	return p
}

func (s *Alias_clauseContext) GetParser() antlr.Parser { return s.parser }

func (s *Alias_clauseContext) Colid() IColidContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IColidContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IColidContext)
}

func (s *Alias_clauseContext) AS() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserAS, 0)
}

func (s *Alias_clauseContext) OPEN_PAREN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserOPEN_PAREN, 0)
}

func (s *Alias_clauseContext) Name_list() IName_listContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IName_listContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IName_listContext)
}

func (s *Alias_clauseContext) CLOSE_PAREN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCLOSE_PAREN, 0)
}

func (s *Alias_clauseContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Alias_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Alias_clauseContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterAlias_clause(s)
	}
}

func (s *Alias_clauseContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitAlias_clause(s)
	}
}

func (s *Alias_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitAlias_clause(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Alias_clause() (localctx IAlias_clauseContext) {
	localctx = NewAlias_clauseContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1062, PostgreSQLParserRULE_alias_clause)
	var _la int

	p.EnterOuterAlt(localctx, 1)
	p.SetState(8370)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}
	_la = p.GetTokenStream().LA(1)

	if _la == PostgreSQLParserAS {
		{
			p.SetState(8369)
			p.Match(PostgreSQLParserAS)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	}
	{
		p.SetState(8372)
		p.Colid()
	}
	p.SetState(8377)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 481, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(8373)
			p.Match(PostgreSQLParserOPEN_PAREN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(8374)
			p.Name_list()
		}
		{
			p.SetState(8375)
			p.Match(PostgreSQLParserCLOSE_PAREN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	} else if p.HasError() { // JIM
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IOpt_alias_clauseContext is an interface to support dynamic dispatch.
type IOpt_alias_clauseContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Table_alias_clause() ITable_alias_clauseContext

	// IsOpt_alias_clauseContext differentiates from other interfaces.
	IsOpt_alias_clauseContext()
}

type Opt_alias_clauseContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyOpt_alias_clauseContext() *Opt_alias_clauseContext {
	var p = new(Opt_alias_clauseContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opt_alias_clause
	return p
}

func InitEmptyOpt_alias_clauseContext(p *Opt_alias_clauseContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opt_alias_clause
}

func (*Opt_alias_clauseContext) IsOpt_alias_clauseContext() {}

func NewOpt_alias_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_alias_clauseContext {
	var p = new(Opt_alias_clauseContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_opt_alias_clause

	return p
}

func (s *Opt_alias_clauseContext) GetParser() antlr.Parser { return s.parser }

func (s *Opt_alias_clauseContext) Table_alias_clause() ITable_alias_clauseContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ITable_alias_clauseContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ITable_alias_clauseContext)
}

func (s *Opt_alias_clauseContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Opt_alias_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Opt_alias_clauseContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterOpt_alias_clause(s)
	}
}

func (s *Opt_alias_clauseContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitOpt_alias_clause(s)
	}
}

func (s *Opt_alias_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitOpt_alias_clause(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Opt_alias_clause() (localctx IOpt_alias_clauseContext) {
	localctx = NewOpt_alias_clauseContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1064, PostgreSQLParserRULE_opt_alias_clause)
	p.SetState(8381)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 482, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(8379)
			p.Table_alias_clause()
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)

	case antlr.ATNInvalidAltNumber:
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// ITable_alias_clauseContext is an interface to support dynamic dispatch.
type ITable_alias_clauseContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Table_alias() ITable_aliasContext
	AS() antlr.TerminalNode
	OPEN_PAREN() antlr.TerminalNode
	Name_list() IName_listContext
	CLOSE_PAREN() antlr.TerminalNode

	// IsTable_alias_clauseContext differentiates from other interfaces.
	IsTable_alias_clauseContext()
}

type Table_alias_clauseContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyTable_alias_clauseContext() *Table_alias_clauseContext {
	var p = new(Table_alias_clauseContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_table_alias_clause
	return p
}

func InitEmptyTable_alias_clauseContext(p *Table_alias_clauseContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_table_alias_clause
}

func (*Table_alias_clauseContext) IsTable_alias_clauseContext() {}

func NewTable_alias_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Table_alias_clauseContext {
	var p = new(Table_alias_clauseContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_table_alias_clause

	return p
}

func (s *Table_alias_clauseContext) GetParser() antlr.Parser { return s.parser }

func (s *Table_alias_clauseContext) Table_alias() ITable_aliasContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ITable_aliasContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ITable_aliasContext)
}

func (s *Table_alias_clauseContext) AS() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserAS, 0)
}

func (s *Table_alias_clauseContext) OPEN_PAREN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserOPEN_PAREN, 0)
}

func (s *Table_alias_clauseContext) Name_list() IName_listContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IName_listContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IName_listContext)
}

func (s *Table_alias_clauseContext) CLOSE_PAREN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCLOSE_PAREN, 0)
}

func (s *Table_alias_clauseContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Table_alias_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Table_alias_clauseContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterTable_alias_clause(s)
	}
}

func (s *Table_alias_clauseContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitTable_alias_clause(s)
	}
}

func (s *Table_alias_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitTable_alias_clause(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Table_alias_clause() (localctx ITable_alias_clauseContext) {
	localctx = NewTable_alias_clauseContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1066, PostgreSQLParserRULE_table_alias_clause)
	var _la int

	p.EnterOuterAlt(localctx, 1)
	p.SetState(8384)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}
	_la = p.GetTokenStream().LA(1)

	if _la == PostgreSQLParserAS {
		{
			p.SetState(8383)
			p.Match(PostgreSQLParserAS)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	}
	{
		p.SetState(8386)
		p.Table_alias()
	}
	p.SetState(8391)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 484, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(8387)
			p.Match(PostgreSQLParserOPEN_PAREN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(8388)
			p.Name_list()
		}
		{
			p.SetState(8389)
			p.Match(PostgreSQLParserCLOSE_PAREN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	} else if p.HasError() { // JIM
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IFunc_alias_clauseContext is an interface to support dynamic dispatch.
type IFunc_alias_clauseContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Alias_clause() IAlias_clauseContext
	OPEN_PAREN() antlr.TerminalNode
	Tablefuncelementlist() ITablefuncelementlistContext
	CLOSE_PAREN() antlr.TerminalNode
	AS() antlr.TerminalNode
	Colid() IColidContext

	// IsFunc_alias_clauseContext differentiates from other interfaces.
	IsFunc_alias_clauseContext()
}

type Func_alias_clauseContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyFunc_alias_clauseContext() *Func_alias_clauseContext {
	var p = new(Func_alias_clauseContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_func_alias_clause
	return p
}

func InitEmptyFunc_alias_clauseContext(p *Func_alias_clauseContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_func_alias_clause
}

func (*Func_alias_clauseContext) IsFunc_alias_clauseContext() {}

func NewFunc_alias_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Func_alias_clauseContext {
	var p = new(Func_alias_clauseContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_func_alias_clause

	return p
}

func (s *Func_alias_clauseContext) GetParser() antlr.Parser { return s.parser }

func (s *Func_alias_clauseContext) Alias_clause() IAlias_clauseContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IAlias_clauseContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IAlias_clauseContext)
}

func (s *Func_alias_clauseContext) OPEN_PAREN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserOPEN_PAREN, 0)
}

func (s *Func_alias_clauseContext) Tablefuncelementlist() ITablefuncelementlistContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ITablefuncelementlistContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ITablefuncelementlistContext)
}

func (s *Func_alias_clauseContext) CLOSE_PAREN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCLOSE_PAREN, 0)
}

func (s *Func_alias_clauseContext) AS() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserAS, 0)
}

func (s *Func_alias_clauseContext) Colid() IColidContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IColidContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IColidContext)
}

func (s *Func_alias_clauseContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Func_alias_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Func_alias_clauseContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterFunc_alias_clause(s)
	}
}

func (s *Func_alias_clauseContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitFunc_alias_clause(s)
	}
}

func (s *Func_alias_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitFunc_alias_clause(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Func_alias_clause() (localctx IFunc_alias_clauseContext) {
	localctx = NewFunc_alias_clauseContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1068, PostgreSQLParserRULE_func_alias_clause)
	var _la int

	p.SetState(8406)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 487, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(8393)
			p.Alias_clause()
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		p.SetState(8399)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}

		switch p.GetTokenStream().LA(1) {
		case PostgreSQLParserAS:
			{
				p.SetState(8394)
				p.Match(PostgreSQLParserAS)
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}
			p.SetState(8396)
			p.GetErrorHandler().Sync(p)
			if p.HasError() {
				goto errorExit
			}
			_la = p.GetTokenStream().LA(1)

			if ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&2459027012145119232) != 0) || ((int64((_la-92)) & ^0x3f) == 0 && ((int64(1)<<(_la-92))&-113665638399) != 0) || ((int64((_la-156)) & ^0x3f) == 0 && ((int64(1)<<(_la-156))&-1) != 0) || ((int64((_la-220)) & ^0x3f) == 0 && ((int64(1)<<(_la-220))&-9663676417) != 0) || ((int64((_la-284)) & ^0x3f) == 0 && ((int64(1)<<(_la-284))&-1) != 0) || ((int64((_la-348)) & ^0x3f) == 0 && ((int64(1)<<(_la-348))&-1) != 0) || ((int64((_la-412)) & ^0x3f) == 0 && ((int64(1)<<(_la-412))&-1152925902653358081) != 0) || ((int64((_la-476)) & ^0x3f) == 0 && ((int64(1)<<(_la-476))&-8796764110849) != 0) || ((int64((_la-540)) & ^0x3f) == 0 && ((int64(1)<<(_la-540))&-1) != 0) || ((int64((_la-604)) & ^0x3f) == 0 && ((int64(1)<<(_la-604))&432345718846390271) != 0) {
				{
					p.SetState(8395)
					p.Colid()
				}

			}

		case PostgreSQLParserAND, PostgreSQLParserARRAY, PostgreSQLParserCOLLATE, PostgreSQLParserCOLUMN, PostgreSQLParserCONSTRAINT, PostgreSQLParserDEFAULT, PostgreSQLParserDO, PostgreSQLParserFETCH, PostgreSQLParserTABLE, PostgreSQLParserIS, PostgreSQLParserLEFT, PostgreSQLParserOUTER_P, PostgreSQLParserOVER, PostgreSQLParserRIGHT, PostgreSQLParserABORT_P, PostgreSQLParserABSOLUTE_P, PostgreSQLParserACCESS, PostgreSQLParserACTION, PostgreSQLParserADD_P, PostgreSQLParserADMIN, PostgreSQLParserAFTER, PostgreSQLParserAGGREGATE, PostgreSQLParserALSO, PostgreSQLParserALTER, PostgreSQLParserALWAYS, PostgreSQLParserASSERTION, PostgreSQLParserASSIGNMENT, PostgreSQLParserAT, PostgreSQLParserATTRIBUTE, PostgreSQLParserBACKWARD, PostgreSQLParserBEFORE, PostgreSQLParserBEGIN_P, PostgreSQLParserBY, PostgreSQLParserCACHE, PostgreSQLParserCALLED, PostgreSQLParserCASCADE, PostgreSQLParserCASCADED, PostgreSQLParserCATALOG, PostgreSQLParserCHAIN, PostgreSQLParserCHARACTERISTICS, PostgreSQLParserCHECKPOINT, PostgreSQLParserCLASS, PostgreSQLParserCLOSE, PostgreSQLParserCLUSTER, PostgreSQLParserCOMMENT, PostgreSQLParserCOMMENTS, PostgreSQLParserCOMMIT, PostgreSQLParserCOMMITTED, PostgreSQLParserCONFIGURATION, PostgreSQLParserCONNECTION, PostgreSQLParserCONSTRAINTS, PostgreSQLParserCONTENT_P, PostgreSQLParserCONTINUE_P, PostgreSQLParserCONVERSION_P, PostgreSQLParserCOPY, PostgreSQLParserCOST, PostgreSQLParserCSV, PostgreSQLParserCURSOR, PostgreSQLParserCYCLE, PostgreSQLParserDATA_P, PostgreSQLParserDATABASE, PostgreSQLParserDAY_P, PostgreSQLParserDEALLOCATE, PostgreSQLParserDECLARE, PostgreSQLParserDEFAULTS, PostgreSQLParserDEFERRED, PostgreSQLParserDEFINER, PostgreSQLParserDELETE_P, PostgreSQLParserDELIMITER, PostgreSQLParserDELIMITERS, PostgreSQLParserDICTIONARY, PostgreSQLParserDISABLE_P, PostgreSQLParserDISCARD, PostgreSQLParserDOCUMENT_P, PostgreSQLParserDOMAIN_P, PostgreSQLParserDOUBLE_P, PostgreSQLParserDROP, PostgreSQLParserEACH, PostgreSQLParserENABLE_P, PostgreSQLParserENCODING, PostgreSQLParserENCRYPTED, PostgreSQLParserENUM_P, PostgreSQLParserESCAPE, PostgreSQLParserEVENT, PostgreSQLParserEXCLUDE, PostgreSQLParserEXCLUDING, PostgreSQLParserEXCLUSIVE, PostgreSQLParserEXECUTE, PostgreSQLParserEXPLAIN, PostgreSQLParserEXTENSION, PostgreSQLParserEXTERNAL, PostgreSQLParserFAMILY, PostgreSQLParserFIRST_P, PostgreSQLParserFOLLOWING, PostgreSQLParserFORCE, PostgreSQLParserFORWARD, PostgreSQLParserFUNCTION, PostgreSQLParserFUNCTIONS, PostgreSQLParserGLOBAL, PostgreSQLParserGRANTED, PostgreSQLParserHANDLER, PostgreSQLParserHEADER_P, PostgreSQLParserHOLD, PostgreSQLParserHOUR_P, PostgreSQLParserIDENTITY_P, PostgreSQLParserIF_P, PostgreSQLParserIMMEDIATE, PostgreSQLParserIMMUTABLE, PostgreSQLParserIMPLICIT_P, PostgreSQLParserINCLUDING, PostgreSQLParserINCREMENT, PostgreSQLParserINDEX, PostgreSQLParserINDEXES, PostgreSQLParserINHERIT, PostgreSQLParserINHERITS, PostgreSQLParserINLINE_P, PostgreSQLParserINSENSITIVE, PostgreSQLParserINSERT, PostgreSQLParserINSTEAD, PostgreSQLParserINVOKER, PostgreSQLParserISOLATION, PostgreSQLParserKEY, PostgreSQLParserLABEL, PostgreSQLParserLANGUAGE, PostgreSQLParserLARGE_P, PostgreSQLParserLAST_P, PostgreSQLParserLEAKPROOF, PostgreSQLParserLEVEL, PostgreSQLParserLISTEN, PostgreSQLParserLOAD, PostgreSQLParserLOCAL, PostgreSQLParserLOCATION, PostgreSQLParserLOCK_P, PostgreSQLParserMAPPING, PostgreSQLParserMATCH, PostgreSQLParserMATERIALIZED, PostgreSQLParserMAXVALUE, PostgreSQLParserMINUTE_P, PostgreSQLParserMINVALUE, PostgreSQLParserMODE, PostgreSQLParserMONTH_P, PostgreSQLParserMOVE, PostgreSQLParserNAME_P, PostgreSQLParserNAMES, PostgreSQLParserNEXT, PostgreSQLParserNO, PostgreSQLParserNOTHING, PostgreSQLParserNOTIFY, PostgreSQLParserNOWAIT, PostgreSQLParserNULLS_P, PostgreSQLParserOBJECT_P, PostgreSQLParserOF, PostgreSQLParserOFF, PostgreSQLParserOIDS, PostgreSQLParserOPERATOR, PostgreSQLParserOPTION, PostgreSQLParserOPTIONS, PostgreSQLParserOWNED, PostgreSQLParserOWNER, PostgreSQLParserPARSER, PostgreSQLParserPARTIAL, PostgreSQLParserPARTITION, PostgreSQLParserPASSING, PostgreSQLParserPASSWORD, PostgreSQLParserPLANS, PostgreSQLParserPRECEDING, PostgreSQLParserPREPARE, PostgreSQLParserPREPARED, PostgreSQLParserPRESERVE, PostgreSQLParserPRIOR, PostgreSQLParserPRIVILEGES, PostgreSQLParserPROCEDURAL, PostgreSQLParserPROCEDURE, PostgreSQLParserPROGRAM, PostgreSQLParserQUOTE, PostgreSQLParserRANGE, PostgreSQLParserREAD, PostgreSQLParserREASSIGN, PostgreSQLParserRECHECK, PostgreSQLParserRECURSIVE, PostgreSQLParserREF, PostgreSQLParserREFRESH, PostgreSQLParserREINDEX, PostgreSQLParserRELATIVE_P, PostgreSQLParserRELEASE, PostgreSQLParserRENAME, PostgreSQLParserREPEATABLE, PostgreSQLParserREPLACE, PostgreSQLParserREPLICA, PostgreSQLParserRESET, PostgreSQLParserRESTART, PostgreSQLParserRESTRICT, PostgreSQLParserRETURNS, PostgreSQLParserREVOKE, PostgreSQLParserROLE, PostgreSQLParserROLLBACK, PostgreSQLParserROWS, PostgreSQLParserRULE, PostgreSQLParserSAVEPOINT, PostgreSQLParserSCHEMA, PostgreSQLParserSCROLL, PostgreSQLParserSEARCH, PostgreSQLParserSECOND_P, PostgreSQLParserSECURITY, PostgreSQLParserSEQUENCE, PostgreSQLParserSEQUENCES, PostgreSQLParserSERIALIZABLE, PostgreSQLParserSERVER, PostgreSQLParserSESSION, PostgreSQLParserSET, PostgreSQLParserSHARE, PostgreSQLParserSHOW, PostgreSQLParserSIMPLE, PostgreSQLParserSNAPSHOT, PostgreSQLParserSTABLE, PostgreSQLParserSTANDALONE_P, PostgreSQLParserSTART, PostgreSQLParserSTATEMENT, PostgreSQLParserSTATISTICS, PostgreSQLParserSTDIN, PostgreSQLParserSTDOUT, PostgreSQLParserSTORAGE, PostgreSQLParserSTRICT_P, PostgreSQLParserSTRIP_P, PostgreSQLParserSYSID, PostgreSQLParserSYSTEM_P, PostgreSQLParserTABLES, PostgreSQLParserTABLESPACE, PostgreSQLParserTEMP, PostgreSQLParserTEMPLATE, PostgreSQLParserTEMPORARY, PostgreSQLParserTEXT_P, PostgreSQLParserTRANSACTION, PostgreSQLParserTRIGGER, PostgreSQLParserTRUNCATE, PostgreSQLParserTRUSTED, PostgreSQLParserTYPE_P, PostgreSQLParserTYPES_P, PostgreSQLParserUNBOUNDED, PostgreSQLParserUNCOMMITTED, PostgreSQLParserUNENCRYPTED, PostgreSQLParserUNKNOWN, PostgreSQLParserUNLISTEN, PostgreSQLParserUNLOGGED, PostgreSQLParserUNTIL, PostgreSQLParserUPDATE, PostgreSQLParserVACUUM, PostgreSQLParserVALID, PostgreSQLParserVALIDATE, PostgreSQLParserVALIDATOR, PostgreSQLParserVARYING, PostgreSQLParserVERSION_P, PostgreSQLParserVIEW, PostgreSQLParserVOLATILE, PostgreSQLParserWHITESPACE_P, PostgreSQLParserWITHOUT, PostgreSQLParserWORK, PostgreSQLParserWRAPPER, PostgreSQLParserWRITE, PostgreSQLParserXML_P, PostgreSQLParserYEAR_P, PostgreSQLParserYES_P, PostgreSQLParserZONE, PostgreSQLParserBETWEEN, PostgreSQLParserBIGINT, PostgreSQLParserBIT, PostgreSQLParserBOOLEAN_P, PostgreSQLParserCHAR_P, PostgreSQLParserCHARACTER, PostgreSQLParserCOALESCE, PostgreSQLParserDEC, PostgreSQLParserDECIMAL_P, PostgreSQLParserEXISTS, PostgreSQLParserEXTRACT, PostgreSQLParserFLOAT_P, PostgreSQLParserGREATEST, PostgreSQLParserINOUT, PostgreSQLParserINT_P, PostgreSQLParserINTEGER, PostgreSQLParserINTERVAL, PostgreSQLParserLEAST, PostgreSQLParserNATIONAL, PostgreSQLParserNCHAR, PostgreSQLParserNONE, PostgreSQLParserNULLIF, PostgreSQLParserNUMERIC, PostgreSQLParserOVERLAY, PostgreSQLParserPOSITION, PostgreSQLParserPRECISION, PostgreSQLParserREAL, PostgreSQLParserROW, PostgreSQLParserSETOF, PostgreSQLParserSMALLINT, PostgreSQLParserSUBSTRING, PostgreSQLParserTIME, PostgreSQLParserTIMESTAMP, PostgreSQLParserTREAT, PostgreSQLParserTRIM, PostgreSQLParserVALUES, PostgreSQLParserVARCHAR, PostgreSQLParserXMLATTRIBUTES, PostgreSQLParserXMLCOMMENT, PostgreSQLParserXMLAGG, PostgreSQLParserXML_IS_WELL_FORMED, PostgreSQLParserXML_IS_WELL_FORMED_DOCUMENT, PostgreSQLParserXML_IS_WELL_FORMED_CONTENT, PostgreSQLParserXPATH, PostgreSQLParserXPATH_EXISTS, PostgreSQLParserXMLCONCAT, PostgreSQLParserXMLELEMENT, PostgreSQLParserXMLEXISTS, PostgreSQLParserXMLFOREST, PostgreSQLParserXMLPARSE, PostgreSQLParserXMLPI, PostgreSQLParserXMLROOT, PostgreSQLParserXMLSERIALIZE, PostgreSQLParserCALL, PostgreSQLParserCURRENT_P, PostgreSQLParserATTACH, PostgreSQLParserDETACH, PostgreSQLParserEXPRESSION, PostgreSQLParserGENERATED, PostgreSQLParserLOGGED, PostgreSQLParserSTORED, PostgreSQLParserINCLUDE, PostgreSQLParserROUTINE, PostgreSQLParserTRANSFORM, PostgreSQLParserIMPORT_P, PostgreSQLParserPOLICY, PostgreSQLParserMETHOD, PostgreSQLParserREFERENCING, PostgreSQLParserNEW, PostgreSQLParserOLD, PostgreSQLParserVALUE_P, PostgreSQLParserSUBSCRIPTION, PostgreSQLParserPUBLICATION, PostgreSQLParserOUT_P, PostgreSQLParserROUTINES, PostgreSQLParserSCHEMAS, PostgreSQLParserPROCEDURES, PostgreSQLParserINPUT_P, PostgreSQLParserSUPPORT, PostgreSQLParserPARALLEL, PostgreSQLParserSQL_P, PostgreSQLParserDEPENDS, PostgreSQLParserOVERRIDING, PostgreSQLParserCONFLICT, PostgreSQLParserSKIP_P, PostgreSQLParserLOCKED, PostgreSQLParserTIES, PostgreSQLParserROLLUP, PostgreSQLParserCUBE, PostgreSQLParserGROUPING, PostgreSQLParserSETS, PostgreSQLParserORDINALITY, PostgreSQLParserXMLTABLE, PostgreSQLParserCOLUMNS, PostgreSQLParserXMLNAMESPACES, PostgreSQLParserROWTYPE, PostgreSQLParserNORMALIZED, PostgreSQLParserWITHIN, PostgreSQLParserFILTER, PostgreSQLParserGROUPS, PostgreSQLParserOTHERS, PostgreSQLParserNFC, PostgreSQLParserNFD, PostgreSQLParserNFKC, PostgreSQLParserNFKD, PostgreSQLParserUESCAPE, PostgreSQLParserVIEWS, PostgreSQLParserNORMALIZE, PostgreSQLParserDUMP, PostgreSQLParserPRINT_STRICT_PARAMS, PostgreSQLParserVARIABLE_CONFLICT, PostgreSQLParserERROR, PostgreSQLParserUSE_VARIABLE, PostgreSQLParserUSE_COLUMN, PostgreSQLParserALIAS, PostgreSQLParserCONSTANT, PostgreSQLParserPERFORM, PostgreSQLParserGET, PostgreSQLParserDIAGNOSTICS, PostgreSQLParserSTACKED, PostgreSQLParserELSIF, PostgreSQLParserREVERSE, PostgreSQLParserSLICE, PostgreSQLParserEXIT, PostgreSQLParserRETURN, PostgreSQLParserQUERY, PostgreSQLParserRAISE, PostgreSQLParserSQLSTATE, PostgreSQLParserDEBUG, PostgreSQLParserLOG, PostgreSQLParserINFO, PostgreSQLParserNOTICE, PostgreSQLParserWARNING, PostgreSQLParserEXCEPTION, PostgreSQLParserASSERT, PostgreSQLParserOPEN, PostgreSQLParserABS, PostgreSQLParserCBRT, PostgreSQLParserCEIL, PostgreSQLParserCEILING, PostgreSQLParserDEGREES, PostgreSQLParserDIV, PostgreSQLParserEXP, PostgreSQLParserFACTORIAL, PostgreSQLParserFLOOR, PostgreSQLParserGCD, PostgreSQLParserLCM, PostgreSQLParserLN, PostgreSQLParserLOG10, PostgreSQLParserMIN_SCALE, PostgreSQLParserMOD, PostgreSQLParserPI, PostgreSQLParserPOWER, PostgreSQLParserRADIANS, PostgreSQLParserROUND, PostgreSQLParserSCALE, PostgreSQLParserSIGN, PostgreSQLParserSQRT, PostgreSQLParserTRIM_SCALE, PostgreSQLParserTRUNC, PostgreSQLParserWIDTH_BUCKET, PostgreSQLParserRANDOM, PostgreSQLParserSETSEED, PostgreSQLParserACOS, PostgreSQLParserACOSD, PostgreSQLParserASIN, PostgreSQLParserASIND, PostgreSQLParserATAN, PostgreSQLParserATAND, PostgreSQLParserATAN2, PostgreSQLParserATAN2D, PostgreSQLParserCOS, PostgreSQLParserCOSD, PostgreSQLParserCOT, PostgreSQLParserCOTD, PostgreSQLParserSIN, PostgreSQLParserSIND, PostgreSQLParserTAN, PostgreSQLParserTAND, PostgreSQLParserSINH, PostgreSQLParserCOSH, PostgreSQLParserTANH, PostgreSQLParserASINH, PostgreSQLParserACOSH, PostgreSQLParserATANH, PostgreSQLParserBIT_LENGTH, PostgreSQLParserCHAR_LENGTH, PostgreSQLParserCHARACTER_LENGTH, PostgreSQLParserLOWER, PostgreSQLParserOCTET_LENGTH, PostgreSQLParserUPPER, PostgreSQLParserASCII, PostgreSQLParserBTRIM, PostgreSQLParserCHR, PostgreSQLParserCONCAT, PostgreSQLParserCONCAT_WS, PostgreSQLParserFORMAT, PostgreSQLParserINITCAP, PostgreSQLParserLENGTH, PostgreSQLParserLPAD, PostgreSQLParserLTRIM, PostgreSQLParserMD5, PostgreSQLParserPARSE_IDENT, PostgreSQLParserPG_CLIENT_ENCODING, PostgreSQLParserQUOTE_IDENT, PostgreSQLParserQUOTE_LITERAL, PostgreSQLParserQUOTE_NULLABLE, PostgreSQLParserREGEXP_COUNT, PostgreSQLParserREGEXP_INSTR, PostgreSQLParserREGEXP_LIKE, PostgreSQLParserREGEXP_MATCH, PostgreSQLParserREGEXP_MATCHES, PostgreSQLParserREGEXP_REPLACE, PostgreSQLParserREGEXP_SPLIT_TO_ARRAY, PostgreSQLParserREGEXP_SPLIT_TO_TABLE, PostgreSQLParserREGEXP_SUBSTR, PostgreSQLParserREPEAT, PostgreSQLParserRPAD, PostgreSQLParserRTRIM, PostgreSQLParserSPLIT_PART, PostgreSQLParserSTARTS_WITH, PostgreSQLParserSTRING_TO_ARRAY, PostgreSQLParserSTRING_TO_TABLE, PostgreSQLParserSTRPOS, PostgreSQLParserSUBSTR, PostgreSQLParserTO_ASCII, PostgreSQLParserTO_HEX, PostgreSQLParserTRANSLATE, PostgreSQLParserUNISTR, PostgreSQLParserAGE, PostgreSQLParserCLOCK_TIMESTAMP, PostgreSQLParserDATE_BIN, PostgreSQLParserDATE_PART, PostgreSQLParserDATE_TRUNC, PostgreSQLParserISFINITE, PostgreSQLParserJUSTIFY_DAYS, PostgreSQLParserJUSTIFY_HOURS, PostgreSQLParserJUSTIFY_INTERVAL, PostgreSQLParserMAKE_DATE, PostgreSQLParserMAKE_INTERVAL, PostgreSQLParserMAKE_TIME, PostgreSQLParserMAKE_TIMESTAMP, PostgreSQLParserMAKE_TIMESTAMPTZ, PostgreSQLParserNOW, PostgreSQLParserSTATEMENT_TIMESTAMP, PostgreSQLParserTIMEOFDAY, PostgreSQLParserTRANSACTION_TIMESTAMP, PostgreSQLParserTO_TIMESTAMP, PostgreSQLParserTO_CHAR, PostgreSQLParserTO_DATE, PostgreSQLParserTO_NUMBER, PostgreSQLParserIdentifier, PostgreSQLParserQuotedIdentifier, PostgreSQLParserUnicodeQuotedIdentifier, PostgreSQLParserPLSQLVARIABLENAME, PostgreSQLParserPLSQLIDENTIFIER:
			{
				p.SetState(8398)
				p.Colid()
			}

		default:
			p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
			goto errorExit
		}
		{
			p.SetState(8401)
			p.Match(PostgreSQLParserOPEN_PAREN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(8402)
			p.Tablefuncelementlist()
		}
		{
			p.SetState(8403)
			p.Match(PostgreSQLParserCLOSE_PAREN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 3:
		p.EnterOuterAlt(localctx, 3)

	case antlr.ATNInvalidAltNumber:
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IJoin_typeContext is an interface to support dynamic dispatch.
type IJoin_typeContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	FULL() antlr.TerminalNode
	LEFT() antlr.TerminalNode
	RIGHT() antlr.TerminalNode
	INNER_P() antlr.TerminalNode
	OUTER_P() antlr.TerminalNode

	// IsJoin_typeContext differentiates from other interfaces.
	IsJoin_typeContext()
}

type Join_typeContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyJoin_typeContext() *Join_typeContext {
	var p = new(Join_typeContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_join_type
	return p
}

func InitEmptyJoin_typeContext(p *Join_typeContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_join_type
}

func (*Join_typeContext) IsJoin_typeContext() {}

func NewJoin_typeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Join_typeContext {
	var p = new(Join_typeContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_join_type

	return p
}

func (s *Join_typeContext) GetParser() antlr.Parser { return s.parser }

func (s *Join_typeContext) FULL() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserFULL, 0)
}

func (s *Join_typeContext) LEFT() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserLEFT, 0)
}

func (s *Join_typeContext) RIGHT() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserRIGHT, 0)
}

func (s *Join_typeContext) INNER_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserINNER_P, 0)
}

func (s *Join_typeContext) OUTER_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserOUTER_P, 0)
}

func (s *Join_typeContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Join_typeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Join_typeContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterJoin_type(s)
	}
}

func (s *Join_typeContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitJoin_type(s)
	}
}

func (s *Join_typeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitJoin_type(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Join_type() (localctx IJoin_typeContext) {
	localctx = NewJoin_typeContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1070, PostgreSQLParserRULE_join_type)
	var _la int

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(8408)
		_la = p.GetTokenStream().LA(1)

		if !((int64((_la-113)) & ^0x3f) == 0 && ((int64(1)<<(_la-113))&8261) != 0) {
			p.GetErrorHandler().RecoverInline(p)
		} else {
			p.GetErrorHandler().ReportMatch(p)
			p.Consume()
		}
	}
	p.SetState(8410)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}
	_la = p.GetTokenStream().LA(1)

	if _la == PostgreSQLParserOUTER_P {
		{
			p.SetState(8409)
			p.Match(PostgreSQLParserOUTER_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IJoin_qualContext is an interface to support dynamic dispatch.
type IJoin_qualContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	USING() antlr.TerminalNode
	OPEN_PAREN() antlr.TerminalNode
	Name_list() IName_listContext
	CLOSE_PAREN() antlr.TerminalNode
	ON() antlr.TerminalNode
	A_expr() IA_exprContext

	// IsJoin_qualContext differentiates from other interfaces.
	IsJoin_qualContext()
}

type Join_qualContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyJoin_qualContext() *Join_qualContext {
	var p = new(Join_qualContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_join_qual
	return p
}

func InitEmptyJoin_qualContext(p *Join_qualContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_join_qual
}

func (*Join_qualContext) IsJoin_qualContext() {}

func NewJoin_qualContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Join_qualContext {
	var p = new(Join_qualContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_join_qual

	return p
}

func (s *Join_qualContext) GetParser() antlr.Parser { return s.parser }

func (s *Join_qualContext) USING() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserUSING, 0)
}

func (s *Join_qualContext) OPEN_PAREN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserOPEN_PAREN, 0)
}

func (s *Join_qualContext) Name_list() IName_listContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IName_listContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IName_listContext)
}

func (s *Join_qualContext) CLOSE_PAREN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCLOSE_PAREN, 0)
}

func (s *Join_qualContext) ON() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserON, 0)
}

func (s *Join_qualContext) A_expr() IA_exprContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IA_exprContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IA_exprContext)
}

func (s *Join_qualContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Join_qualContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Join_qualContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterJoin_qual(s)
	}
}

func (s *Join_qualContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitJoin_qual(s)
	}
}

func (s *Join_qualContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitJoin_qual(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Join_qual() (localctx IJoin_qualContext) {
	localctx = NewJoin_qualContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1072, PostgreSQLParserRULE_join_qual)
	p.SetState(8419)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetTokenStream().LA(1) {
	case PostgreSQLParserUSING:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(8412)
			p.Match(PostgreSQLParserUSING)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(8413)
			p.Match(PostgreSQLParserOPEN_PAREN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(8414)
			p.Name_list()
		}
		{
			p.SetState(8415)
			p.Match(PostgreSQLParserCLOSE_PAREN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case PostgreSQLParserON:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(8417)
			p.Match(PostgreSQLParserON)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(8418)
			p.A_expr()
		}

	default:
		p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IRelation_exprContext is an interface to support dynamic dispatch.
type IRelation_exprContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Qualified_name() IQualified_nameContext
	STAR() antlr.TerminalNode
	ONLY() antlr.TerminalNode
	OPEN_PAREN() antlr.TerminalNode
	CLOSE_PAREN() antlr.TerminalNode

	// IsRelation_exprContext differentiates from other interfaces.
	IsRelation_exprContext()
}

type Relation_exprContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyRelation_exprContext() *Relation_exprContext {
	var p = new(Relation_exprContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_relation_expr
	return p
}

func InitEmptyRelation_exprContext(p *Relation_exprContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_relation_expr
}

func (*Relation_exprContext) IsRelation_exprContext() {}

func NewRelation_exprContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Relation_exprContext {
	var p = new(Relation_exprContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_relation_expr

	return p
}

func (s *Relation_exprContext) GetParser() antlr.Parser { return s.parser }

func (s *Relation_exprContext) Qualified_name() IQualified_nameContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IQualified_nameContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IQualified_nameContext)
}

func (s *Relation_exprContext) STAR() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserSTAR, 0)
}

func (s *Relation_exprContext) ONLY() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserONLY, 0)
}

func (s *Relation_exprContext) OPEN_PAREN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserOPEN_PAREN, 0)
}

func (s *Relation_exprContext) CLOSE_PAREN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCLOSE_PAREN, 0)
}

func (s *Relation_exprContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Relation_exprContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Relation_exprContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterRelation_expr(s)
	}
}

func (s *Relation_exprContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitRelation_expr(s)
	}
}

func (s *Relation_exprContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitRelation_expr(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Relation_expr() (localctx IRelation_exprContext) {
	localctx = NewRelation_exprContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1074, PostgreSQLParserRULE_relation_expr)
	var _la int

	p.SetState(8433)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetTokenStream().LA(1) {
	case PostgreSQLParserAND, PostgreSQLParserARRAY, PostgreSQLParserCOLLATE, PostgreSQLParserCOLUMN, PostgreSQLParserCONSTRAINT, PostgreSQLParserDEFAULT, PostgreSQLParserDO, PostgreSQLParserFETCH, PostgreSQLParserTABLE, PostgreSQLParserIS, PostgreSQLParserLEFT, PostgreSQLParserOUTER_P, PostgreSQLParserOVER, PostgreSQLParserRIGHT, PostgreSQLParserABORT_P, PostgreSQLParserABSOLUTE_P, PostgreSQLParserACCESS, PostgreSQLParserACTION, PostgreSQLParserADD_P, PostgreSQLParserADMIN, PostgreSQLParserAFTER, PostgreSQLParserAGGREGATE, PostgreSQLParserALSO, PostgreSQLParserALTER, PostgreSQLParserALWAYS, PostgreSQLParserASSERTION, PostgreSQLParserASSIGNMENT, PostgreSQLParserAT, PostgreSQLParserATTRIBUTE, PostgreSQLParserBACKWARD, PostgreSQLParserBEFORE, PostgreSQLParserBEGIN_P, PostgreSQLParserBY, PostgreSQLParserCACHE, PostgreSQLParserCALLED, PostgreSQLParserCASCADE, PostgreSQLParserCASCADED, PostgreSQLParserCATALOG, PostgreSQLParserCHAIN, PostgreSQLParserCHARACTERISTICS, PostgreSQLParserCHECKPOINT, PostgreSQLParserCLASS, PostgreSQLParserCLOSE, PostgreSQLParserCLUSTER, PostgreSQLParserCOMMENT, PostgreSQLParserCOMMENTS, PostgreSQLParserCOMMIT, PostgreSQLParserCOMMITTED, PostgreSQLParserCONFIGURATION, PostgreSQLParserCONNECTION, PostgreSQLParserCONSTRAINTS, PostgreSQLParserCONTENT_P, PostgreSQLParserCONTINUE_P, PostgreSQLParserCONVERSION_P, PostgreSQLParserCOPY, PostgreSQLParserCOST, PostgreSQLParserCSV, PostgreSQLParserCURSOR, PostgreSQLParserCYCLE, PostgreSQLParserDATA_P, PostgreSQLParserDATABASE, PostgreSQLParserDAY_P, PostgreSQLParserDEALLOCATE, PostgreSQLParserDECLARE, PostgreSQLParserDEFAULTS, PostgreSQLParserDEFERRED, PostgreSQLParserDEFINER, PostgreSQLParserDELETE_P, PostgreSQLParserDELIMITER, PostgreSQLParserDELIMITERS, PostgreSQLParserDICTIONARY, PostgreSQLParserDISABLE_P, PostgreSQLParserDISCARD, PostgreSQLParserDOCUMENT_P, PostgreSQLParserDOMAIN_P, PostgreSQLParserDOUBLE_P, PostgreSQLParserDROP, PostgreSQLParserEACH, PostgreSQLParserENABLE_P, PostgreSQLParserENCODING, PostgreSQLParserENCRYPTED, PostgreSQLParserENUM_P, PostgreSQLParserESCAPE, PostgreSQLParserEVENT, PostgreSQLParserEXCLUDE, PostgreSQLParserEXCLUDING, PostgreSQLParserEXCLUSIVE, PostgreSQLParserEXECUTE, PostgreSQLParserEXPLAIN, PostgreSQLParserEXTENSION, PostgreSQLParserEXTERNAL, PostgreSQLParserFAMILY, PostgreSQLParserFIRST_P, PostgreSQLParserFOLLOWING, PostgreSQLParserFORCE, PostgreSQLParserFORWARD, PostgreSQLParserFUNCTION, PostgreSQLParserFUNCTIONS, PostgreSQLParserGLOBAL, PostgreSQLParserGRANTED, PostgreSQLParserHANDLER, PostgreSQLParserHEADER_P, PostgreSQLParserHOLD, PostgreSQLParserHOUR_P, PostgreSQLParserIDENTITY_P, PostgreSQLParserIF_P, PostgreSQLParserIMMEDIATE, PostgreSQLParserIMMUTABLE, PostgreSQLParserIMPLICIT_P, PostgreSQLParserINCLUDING, PostgreSQLParserINCREMENT, PostgreSQLParserINDEX, PostgreSQLParserINDEXES, PostgreSQLParserINHERIT, PostgreSQLParserINHERITS, PostgreSQLParserINLINE_P, PostgreSQLParserINSENSITIVE, PostgreSQLParserINSERT, PostgreSQLParserINSTEAD, PostgreSQLParserINVOKER, PostgreSQLParserISOLATION, PostgreSQLParserKEY, PostgreSQLParserLABEL, PostgreSQLParserLANGUAGE, PostgreSQLParserLARGE_P, PostgreSQLParserLAST_P, PostgreSQLParserLEAKPROOF, PostgreSQLParserLEVEL, PostgreSQLParserLISTEN, PostgreSQLParserLOAD, PostgreSQLParserLOCAL, PostgreSQLParserLOCATION, PostgreSQLParserLOCK_P, PostgreSQLParserMAPPING, PostgreSQLParserMATCH, PostgreSQLParserMATERIALIZED, PostgreSQLParserMAXVALUE, PostgreSQLParserMINUTE_P, PostgreSQLParserMINVALUE, PostgreSQLParserMODE, PostgreSQLParserMONTH_P, PostgreSQLParserMOVE, PostgreSQLParserNAME_P, PostgreSQLParserNAMES, PostgreSQLParserNEXT, PostgreSQLParserNO, PostgreSQLParserNOTHING, PostgreSQLParserNOTIFY, PostgreSQLParserNOWAIT, PostgreSQLParserNULLS_P, PostgreSQLParserOBJECT_P, PostgreSQLParserOF, PostgreSQLParserOFF, PostgreSQLParserOIDS, PostgreSQLParserOPERATOR, PostgreSQLParserOPTION, PostgreSQLParserOPTIONS, PostgreSQLParserOWNED, PostgreSQLParserOWNER, PostgreSQLParserPARSER, PostgreSQLParserPARTIAL, PostgreSQLParserPARTITION, PostgreSQLParserPASSING, PostgreSQLParserPASSWORD, PostgreSQLParserPLANS, PostgreSQLParserPRECEDING, PostgreSQLParserPREPARE, PostgreSQLParserPREPARED, PostgreSQLParserPRESERVE, PostgreSQLParserPRIOR, PostgreSQLParserPRIVILEGES, PostgreSQLParserPROCEDURAL, PostgreSQLParserPROCEDURE, PostgreSQLParserPROGRAM, PostgreSQLParserQUOTE, PostgreSQLParserRANGE, PostgreSQLParserREAD, PostgreSQLParserREASSIGN, PostgreSQLParserRECHECK, PostgreSQLParserRECURSIVE, PostgreSQLParserREF, PostgreSQLParserREFRESH, PostgreSQLParserREINDEX, PostgreSQLParserRELATIVE_P, PostgreSQLParserRELEASE, PostgreSQLParserRENAME, PostgreSQLParserREPEATABLE, PostgreSQLParserREPLACE, PostgreSQLParserREPLICA, PostgreSQLParserRESET, PostgreSQLParserRESTART, PostgreSQLParserRESTRICT, PostgreSQLParserRETURNS, PostgreSQLParserREVOKE, PostgreSQLParserROLE, PostgreSQLParserROLLBACK, PostgreSQLParserROWS, PostgreSQLParserRULE, PostgreSQLParserSAVEPOINT, PostgreSQLParserSCHEMA, PostgreSQLParserSCROLL, PostgreSQLParserSEARCH, PostgreSQLParserSECOND_P, PostgreSQLParserSECURITY, PostgreSQLParserSEQUENCE, PostgreSQLParserSEQUENCES, PostgreSQLParserSERIALIZABLE, PostgreSQLParserSERVER, PostgreSQLParserSESSION, PostgreSQLParserSET, PostgreSQLParserSHARE, PostgreSQLParserSHOW, PostgreSQLParserSIMPLE, PostgreSQLParserSNAPSHOT, PostgreSQLParserSTABLE, PostgreSQLParserSTANDALONE_P, PostgreSQLParserSTART, PostgreSQLParserSTATEMENT, PostgreSQLParserSTATISTICS, PostgreSQLParserSTDIN, PostgreSQLParserSTDOUT, PostgreSQLParserSTORAGE, PostgreSQLParserSTRICT_P, PostgreSQLParserSTRIP_P, PostgreSQLParserSYSID, PostgreSQLParserSYSTEM_P, PostgreSQLParserTABLES, PostgreSQLParserTABLESPACE, PostgreSQLParserTEMP, PostgreSQLParserTEMPLATE, PostgreSQLParserTEMPORARY, PostgreSQLParserTEXT_P, PostgreSQLParserTRANSACTION, PostgreSQLParserTRIGGER, PostgreSQLParserTRUNCATE, PostgreSQLParserTRUSTED, PostgreSQLParserTYPE_P, PostgreSQLParserTYPES_P, PostgreSQLParserUNBOUNDED, PostgreSQLParserUNCOMMITTED, PostgreSQLParserUNENCRYPTED, PostgreSQLParserUNKNOWN, PostgreSQLParserUNLISTEN, PostgreSQLParserUNLOGGED, PostgreSQLParserUNTIL, PostgreSQLParserUPDATE, PostgreSQLParserVACUUM, PostgreSQLParserVALID, PostgreSQLParserVALIDATE, PostgreSQLParserVALIDATOR, PostgreSQLParserVARYING, PostgreSQLParserVERSION_P, PostgreSQLParserVIEW, PostgreSQLParserVOLATILE, PostgreSQLParserWHITESPACE_P, PostgreSQLParserWITHOUT, PostgreSQLParserWORK, PostgreSQLParserWRAPPER, PostgreSQLParserWRITE, PostgreSQLParserXML_P, PostgreSQLParserYEAR_P, PostgreSQLParserYES_P, PostgreSQLParserZONE, PostgreSQLParserBETWEEN, PostgreSQLParserBIGINT, PostgreSQLParserBIT, PostgreSQLParserBOOLEAN_P, PostgreSQLParserCHAR_P, PostgreSQLParserCHARACTER, PostgreSQLParserCOALESCE, PostgreSQLParserDEC, PostgreSQLParserDECIMAL_P, PostgreSQLParserEXISTS, PostgreSQLParserEXTRACT, PostgreSQLParserFLOAT_P, PostgreSQLParserGREATEST, PostgreSQLParserINOUT, PostgreSQLParserINT_P, PostgreSQLParserINTEGER, PostgreSQLParserINTERVAL, PostgreSQLParserLEAST, PostgreSQLParserNATIONAL, PostgreSQLParserNCHAR, PostgreSQLParserNONE, PostgreSQLParserNULLIF, PostgreSQLParserNUMERIC, PostgreSQLParserOVERLAY, PostgreSQLParserPOSITION, PostgreSQLParserPRECISION, PostgreSQLParserREAL, PostgreSQLParserROW, PostgreSQLParserSETOF, PostgreSQLParserSMALLINT, PostgreSQLParserSUBSTRING, PostgreSQLParserTIME, PostgreSQLParserTIMESTAMP, PostgreSQLParserTREAT, PostgreSQLParserTRIM, PostgreSQLParserVALUES, PostgreSQLParserVARCHAR, PostgreSQLParserXMLATTRIBUTES, PostgreSQLParserXMLCOMMENT, PostgreSQLParserXMLAGG, PostgreSQLParserXML_IS_WELL_FORMED, PostgreSQLParserXML_IS_WELL_FORMED_DOCUMENT, PostgreSQLParserXML_IS_WELL_FORMED_CONTENT, PostgreSQLParserXPATH, PostgreSQLParserXPATH_EXISTS, PostgreSQLParserXMLCONCAT, PostgreSQLParserXMLELEMENT, PostgreSQLParserXMLEXISTS, PostgreSQLParserXMLFOREST, PostgreSQLParserXMLPARSE, PostgreSQLParserXMLPI, PostgreSQLParserXMLROOT, PostgreSQLParserXMLSERIALIZE, PostgreSQLParserCALL, PostgreSQLParserCURRENT_P, PostgreSQLParserATTACH, PostgreSQLParserDETACH, PostgreSQLParserEXPRESSION, PostgreSQLParserGENERATED, PostgreSQLParserLOGGED, PostgreSQLParserSTORED, PostgreSQLParserINCLUDE, PostgreSQLParserROUTINE, PostgreSQLParserTRANSFORM, PostgreSQLParserIMPORT_P, PostgreSQLParserPOLICY, PostgreSQLParserMETHOD, PostgreSQLParserREFERENCING, PostgreSQLParserNEW, PostgreSQLParserOLD, PostgreSQLParserVALUE_P, PostgreSQLParserSUBSCRIPTION, PostgreSQLParserPUBLICATION, PostgreSQLParserOUT_P, PostgreSQLParserROUTINES, PostgreSQLParserSCHEMAS, PostgreSQLParserPROCEDURES, PostgreSQLParserINPUT_P, PostgreSQLParserSUPPORT, PostgreSQLParserPARALLEL, PostgreSQLParserSQL_P, PostgreSQLParserDEPENDS, PostgreSQLParserOVERRIDING, PostgreSQLParserCONFLICT, PostgreSQLParserSKIP_P, PostgreSQLParserLOCKED, PostgreSQLParserTIES, PostgreSQLParserROLLUP, PostgreSQLParserCUBE, PostgreSQLParserGROUPING, PostgreSQLParserSETS, PostgreSQLParserORDINALITY, PostgreSQLParserXMLTABLE, PostgreSQLParserCOLUMNS, PostgreSQLParserXMLNAMESPACES, PostgreSQLParserROWTYPE, PostgreSQLParserNORMALIZED, PostgreSQLParserWITHIN, PostgreSQLParserFILTER, PostgreSQLParserGROUPS, PostgreSQLParserOTHERS, PostgreSQLParserNFC, PostgreSQLParserNFD, PostgreSQLParserNFKC, PostgreSQLParserNFKD, PostgreSQLParserUESCAPE, PostgreSQLParserVIEWS, PostgreSQLParserNORMALIZE, PostgreSQLParserDUMP, PostgreSQLParserPRINT_STRICT_PARAMS, PostgreSQLParserVARIABLE_CONFLICT, PostgreSQLParserERROR, PostgreSQLParserUSE_VARIABLE, PostgreSQLParserUSE_COLUMN, PostgreSQLParserALIAS, PostgreSQLParserCONSTANT, PostgreSQLParserPERFORM, PostgreSQLParserGET, PostgreSQLParserDIAGNOSTICS, PostgreSQLParserSTACKED, PostgreSQLParserELSIF, PostgreSQLParserREVERSE, PostgreSQLParserSLICE, PostgreSQLParserEXIT, PostgreSQLParserRETURN, PostgreSQLParserQUERY, PostgreSQLParserRAISE, PostgreSQLParserSQLSTATE, PostgreSQLParserDEBUG, PostgreSQLParserLOG, PostgreSQLParserINFO, PostgreSQLParserNOTICE, PostgreSQLParserWARNING, PostgreSQLParserEXCEPTION, PostgreSQLParserASSERT, PostgreSQLParserOPEN, PostgreSQLParserABS, PostgreSQLParserCBRT, PostgreSQLParserCEIL, PostgreSQLParserCEILING, PostgreSQLParserDEGREES, PostgreSQLParserDIV, PostgreSQLParserEXP, PostgreSQLParserFACTORIAL, PostgreSQLParserFLOOR, PostgreSQLParserGCD, PostgreSQLParserLCM, PostgreSQLParserLN, PostgreSQLParserLOG10, PostgreSQLParserMIN_SCALE, PostgreSQLParserMOD, PostgreSQLParserPI, PostgreSQLParserPOWER, PostgreSQLParserRADIANS, PostgreSQLParserROUND, PostgreSQLParserSCALE, PostgreSQLParserSIGN, PostgreSQLParserSQRT, PostgreSQLParserTRIM_SCALE, PostgreSQLParserTRUNC, PostgreSQLParserWIDTH_BUCKET, PostgreSQLParserRANDOM, PostgreSQLParserSETSEED, PostgreSQLParserACOS, PostgreSQLParserACOSD, PostgreSQLParserASIN, PostgreSQLParserASIND, PostgreSQLParserATAN, PostgreSQLParserATAND, PostgreSQLParserATAN2, PostgreSQLParserATAN2D, PostgreSQLParserCOS, PostgreSQLParserCOSD, PostgreSQLParserCOT, PostgreSQLParserCOTD, PostgreSQLParserSIN, PostgreSQLParserSIND, PostgreSQLParserTAN, PostgreSQLParserTAND, PostgreSQLParserSINH, PostgreSQLParserCOSH, PostgreSQLParserTANH, PostgreSQLParserASINH, PostgreSQLParserACOSH, PostgreSQLParserATANH, PostgreSQLParserBIT_LENGTH, PostgreSQLParserCHAR_LENGTH, PostgreSQLParserCHARACTER_LENGTH, PostgreSQLParserLOWER, PostgreSQLParserOCTET_LENGTH, PostgreSQLParserUPPER, PostgreSQLParserASCII, PostgreSQLParserBTRIM, PostgreSQLParserCHR, PostgreSQLParserCONCAT, PostgreSQLParserCONCAT_WS, PostgreSQLParserFORMAT, PostgreSQLParserINITCAP, PostgreSQLParserLENGTH, PostgreSQLParserLPAD, PostgreSQLParserLTRIM, PostgreSQLParserMD5, PostgreSQLParserPARSE_IDENT, PostgreSQLParserPG_CLIENT_ENCODING, PostgreSQLParserQUOTE_IDENT, PostgreSQLParserQUOTE_LITERAL, PostgreSQLParserQUOTE_NULLABLE, PostgreSQLParserREGEXP_COUNT, PostgreSQLParserREGEXP_INSTR, PostgreSQLParserREGEXP_LIKE, PostgreSQLParserREGEXP_MATCH, PostgreSQLParserREGEXP_MATCHES, PostgreSQLParserREGEXP_REPLACE, PostgreSQLParserREGEXP_SPLIT_TO_ARRAY, PostgreSQLParserREGEXP_SPLIT_TO_TABLE, PostgreSQLParserREGEXP_SUBSTR, PostgreSQLParserREPEAT, PostgreSQLParserRPAD, PostgreSQLParserRTRIM, PostgreSQLParserSPLIT_PART, PostgreSQLParserSTARTS_WITH, PostgreSQLParserSTRING_TO_ARRAY, PostgreSQLParserSTRING_TO_TABLE, PostgreSQLParserSTRPOS, PostgreSQLParserSUBSTR, PostgreSQLParserTO_ASCII, PostgreSQLParserTO_HEX, PostgreSQLParserTRANSLATE, PostgreSQLParserUNISTR, PostgreSQLParserAGE, PostgreSQLParserCLOCK_TIMESTAMP, PostgreSQLParserDATE_BIN, PostgreSQLParserDATE_PART, PostgreSQLParserDATE_TRUNC, PostgreSQLParserISFINITE, PostgreSQLParserJUSTIFY_DAYS, PostgreSQLParserJUSTIFY_HOURS, PostgreSQLParserJUSTIFY_INTERVAL, PostgreSQLParserMAKE_DATE, PostgreSQLParserMAKE_INTERVAL, PostgreSQLParserMAKE_TIME, PostgreSQLParserMAKE_TIMESTAMP, PostgreSQLParserMAKE_TIMESTAMPTZ, PostgreSQLParserNOW, PostgreSQLParserSTATEMENT_TIMESTAMP, PostgreSQLParserTIMEOFDAY, PostgreSQLParserTRANSACTION_TIMESTAMP, PostgreSQLParserTO_TIMESTAMP, PostgreSQLParserTO_CHAR, PostgreSQLParserTO_DATE, PostgreSQLParserTO_NUMBER, PostgreSQLParserIdentifier, PostgreSQLParserQuotedIdentifier, PostgreSQLParserUnicodeQuotedIdentifier, PostgreSQLParserPLSQLVARIABLENAME, PostgreSQLParserPLSQLIDENTIFIER:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(8421)
			p.Qualified_name()
		}
		p.SetState(8423)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}
		_la = p.GetTokenStream().LA(1)

		if _la == PostgreSQLParserSTAR {
			{
				p.SetState(8422)
				p.Match(PostgreSQLParserSTAR)
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}

		}

	case PostgreSQLParserONLY:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(8425)
			p.Match(PostgreSQLParserONLY)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		p.SetState(8431)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}

		switch p.GetTokenStream().LA(1) {
		case PostgreSQLParserAND, PostgreSQLParserARRAY, PostgreSQLParserCOLLATE, PostgreSQLParserCOLUMN, PostgreSQLParserCONSTRAINT, PostgreSQLParserDEFAULT, PostgreSQLParserDO, PostgreSQLParserFETCH, PostgreSQLParserTABLE, PostgreSQLParserIS, PostgreSQLParserLEFT, PostgreSQLParserOUTER_P, PostgreSQLParserOVER, PostgreSQLParserRIGHT, PostgreSQLParserABORT_P, PostgreSQLParserABSOLUTE_P, PostgreSQLParserACCESS, PostgreSQLParserACTION, PostgreSQLParserADD_P, PostgreSQLParserADMIN, PostgreSQLParserAFTER, PostgreSQLParserAGGREGATE, PostgreSQLParserALSO, PostgreSQLParserALTER, PostgreSQLParserALWAYS, PostgreSQLParserASSERTION, PostgreSQLParserASSIGNMENT, PostgreSQLParserAT, PostgreSQLParserATTRIBUTE, PostgreSQLParserBACKWARD, PostgreSQLParserBEFORE, PostgreSQLParserBEGIN_P, PostgreSQLParserBY, PostgreSQLParserCACHE, PostgreSQLParserCALLED, PostgreSQLParserCASCADE, PostgreSQLParserCASCADED, PostgreSQLParserCATALOG, PostgreSQLParserCHAIN, PostgreSQLParserCHARACTERISTICS, PostgreSQLParserCHECKPOINT, PostgreSQLParserCLASS, PostgreSQLParserCLOSE, PostgreSQLParserCLUSTER, PostgreSQLParserCOMMENT, PostgreSQLParserCOMMENTS, PostgreSQLParserCOMMIT, PostgreSQLParserCOMMITTED, PostgreSQLParserCONFIGURATION, PostgreSQLParserCONNECTION, PostgreSQLParserCONSTRAINTS, PostgreSQLParserCONTENT_P, PostgreSQLParserCONTINUE_P, PostgreSQLParserCONVERSION_P, PostgreSQLParserCOPY, PostgreSQLParserCOST, PostgreSQLParserCSV, PostgreSQLParserCURSOR, PostgreSQLParserCYCLE, PostgreSQLParserDATA_P, PostgreSQLParserDATABASE, PostgreSQLParserDAY_P, PostgreSQLParserDEALLOCATE, PostgreSQLParserDECLARE, PostgreSQLParserDEFAULTS, PostgreSQLParserDEFERRED, PostgreSQLParserDEFINER, PostgreSQLParserDELETE_P, PostgreSQLParserDELIMITER, PostgreSQLParserDELIMITERS, PostgreSQLParserDICTIONARY, PostgreSQLParserDISABLE_P, PostgreSQLParserDISCARD, PostgreSQLParserDOCUMENT_P, PostgreSQLParserDOMAIN_P, PostgreSQLParserDOUBLE_P, PostgreSQLParserDROP, PostgreSQLParserEACH, PostgreSQLParserENABLE_P, PostgreSQLParserENCODING, PostgreSQLParserENCRYPTED, PostgreSQLParserENUM_P, PostgreSQLParserESCAPE, PostgreSQLParserEVENT, PostgreSQLParserEXCLUDE, PostgreSQLParserEXCLUDING, PostgreSQLParserEXCLUSIVE, PostgreSQLParserEXECUTE, PostgreSQLParserEXPLAIN, PostgreSQLParserEXTENSION, PostgreSQLParserEXTERNAL, PostgreSQLParserFAMILY, PostgreSQLParserFIRST_P, PostgreSQLParserFOLLOWING, PostgreSQLParserFORCE, PostgreSQLParserFORWARD, PostgreSQLParserFUNCTION, PostgreSQLParserFUNCTIONS, PostgreSQLParserGLOBAL, PostgreSQLParserGRANTED, PostgreSQLParserHANDLER, PostgreSQLParserHEADER_P, PostgreSQLParserHOLD, PostgreSQLParserHOUR_P, PostgreSQLParserIDENTITY_P, PostgreSQLParserIF_P, PostgreSQLParserIMMEDIATE, PostgreSQLParserIMMUTABLE, PostgreSQLParserIMPLICIT_P, PostgreSQLParserINCLUDING, PostgreSQLParserINCREMENT, PostgreSQLParserINDEX, PostgreSQLParserINDEXES, PostgreSQLParserINHERIT, PostgreSQLParserINHERITS, PostgreSQLParserINLINE_P, PostgreSQLParserINSENSITIVE, PostgreSQLParserINSERT, PostgreSQLParserINSTEAD, PostgreSQLParserINVOKER, PostgreSQLParserISOLATION, PostgreSQLParserKEY, PostgreSQLParserLABEL, PostgreSQLParserLANGUAGE, PostgreSQLParserLARGE_P, PostgreSQLParserLAST_P, PostgreSQLParserLEAKPROOF, PostgreSQLParserLEVEL, PostgreSQLParserLISTEN, PostgreSQLParserLOAD, PostgreSQLParserLOCAL, PostgreSQLParserLOCATION, PostgreSQLParserLOCK_P, PostgreSQLParserMAPPING, PostgreSQLParserMATCH, PostgreSQLParserMATERIALIZED, PostgreSQLParserMAXVALUE, PostgreSQLParserMINUTE_P, PostgreSQLParserMINVALUE, PostgreSQLParserMODE, PostgreSQLParserMONTH_P, PostgreSQLParserMOVE, PostgreSQLParserNAME_P, PostgreSQLParserNAMES, PostgreSQLParserNEXT, PostgreSQLParserNO, PostgreSQLParserNOTHING, PostgreSQLParserNOTIFY, PostgreSQLParserNOWAIT, PostgreSQLParserNULLS_P, PostgreSQLParserOBJECT_P, PostgreSQLParserOF, PostgreSQLParserOFF, PostgreSQLParserOIDS, PostgreSQLParserOPERATOR, PostgreSQLParserOPTION, PostgreSQLParserOPTIONS, PostgreSQLParserOWNED, PostgreSQLParserOWNER, PostgreSQLParserPARSER, PostgreSQLParserPARTIAL, PostgreSQLParserPARTITION, PostgreSQLParserPASSING, PostgreSQLParserPASSWORD, PostgreSQLParserPLANS, PostgreSQLParserPRECEDING, PostgreSQLParserPREPARE, PostgreSQLParserPREPARED, PostgreSQLParserPRESERVE, PostgreSQLParserPRIOR, PostgreSQLParserPRIVILEGES, PostgreSQLParserPROCEDURAL, PostgreSQLParserPROCEDURE, PostgreSQLParserPROGRAM, PostgreSQLParserQUOTE, PostgreSQLParserRANGE, PostgreSQLParserREAD, PostgreSQLParserREASSIGN, PostgreSQLParserRECHECK, PostgreSQLParserRECURSIVE, PostgreSQLParserREF, PostgreSQLParserREFRESH, PostgreSQLParserREINDEX, PostgreSQLParserRELATIVE_P, PostgreSQLParserRELEASE, PostgreSQLParserRENAME, PostgreSQLParserREPEATABLE, PostgreSQLParserREPLACE, PostgreSQLParserREPLICA, PostgreSQLParserRESET, PostgreSQLParserRESTART, PostgreSQLParserRESTRICT, PostgreSQLParserRETURNS, PostgreSQLParserREVOKE, PostgreSQLParserROLE, PostgreSQLParserROLLBACK, PostgreSQLParserROWS, PostgreSQLParserRULE, PostgreSQLParserSAVEPOINT, PostgreSQLParserSCHEMA, PostgreSQLParserSCROLL, PostgreSQLParserSEARCH, PostgreSQLParserSECOND_P, PostgreSQLParserSECURITY, PostgreSQLParserSEQUENCE, PostgreSQLParserSEQUENCES, PostgreSQLParserSERIALIZABLE, PostgreSQLParserSERVER, PostgreSQLParserSESSION, PostgreSQLParserSET, PostgreSQLParserSHARE, PostgreSQLParserSHOW, PostgreSQLParserSIMPLE, PostgreSQLParserSNAPSHOT, PostgreSQLParserSTABLE, PostgreSQLParserSTANDALONE_P, PostgreSQLParserSTART, PostgreSQLParserSTATEMENT, PostgreSQLParserSTATISTICS, PostgreSQLParserSTDIN, PostgreSQLParserSTDOUT, PostgreSQLParserSTORAGE, PostgreSQLParserSTRICT_P, PostgreSQLParserSTRIP_P, PostgreSQLParserSYSID, PostgreSQLParserSYSTEM_P, PostgreSQLParserTABLES, PostgreSQLParserTABLESPACE, PostgreSQLParserTEMP, PostgreSQLParserTEMPLATE, PostgreSQLParserTEMPORARY, PostgreSQLParserTEXT_P, PostgreSQLParserTRANSACTION, PostgreSQLParserTRIGGER, PostgreSQLParserTRUNCATE, PostgreSQLParserTRUSTED, PostgreSQLParserTYPE_P, PostgreSQLParserTYPES_P, PostgreSQLParserUNBOUNDED, PostgreSQLParserUNCOMMITTED, PostgreSQLParserUNENCRYPTED, PostgreSQLParserUNKNOWN, PostgreSQLParserUNLISTEN, PostgreSQLParserUNLOGGED, PostgreSQLParserUNTIL, PostgreSQLParserUPDATE, PostgreSQLParserVACUUM, PostgreSQLParserVALID, PostgreSQLParserVALIDATE, PostgreSQLParserVALIDATOR, PostgreSQLParserVARYING, PostgreSQLParserVERSION_P, PostgreSQLParserVIEW, PostgreSQLParserVOLATILE, PostgreSQLParserWHITESPACE_P, PostgreSQLParserWITHOUT, PostgreSQLParserWORK, PostgreSQLParserWRAPPER, PostgreSQLParserWRITE, PostgreSQLParserXML_P, PostgreSQLParserYEAR_P, PostgreSQLParserYES_P, PostgreSQLParserZONE, PostgreSQLParserBETWEEN, PostgreSQLParserBIGINT, PostgreSQLParserBIT, PostgreSQLParserBOOLEAN_P, PostgreSQLParserCHAR_P, PostgreSQLParserCHARACTER, PostgreSQLParserCOALESCE, PostgreSQLParserDEC, PostgreSQLParserDECIMAL_P, PostgreSQLParserEXISTS, PostgreSQLParserEXTRACT, PostgreSQLParserFLOAT_P, PostgreSQLParserGREATEST, PostgreSQLParserINOUT, PostgreSQLParserINT_P, PostgreSQLParserINTEGER, PostgreSQLParserINTERVAL, PostgreSQLParserLEAST, PostgreSQLParserNATIONAL, PostgreSQLParserNCHAR, PostgreSQLParserNONE, PostgreSQLParserNULLIF, PostgreSQLParserNUMERIC, PostgreSQLParserOVERLAY, PostgreSQLParserPOSITION, PostgreSQLParserPRECISION, PostgreSQLParserREAL, PostgreSQLParserROW, PostgreSQLParserSETOF, PostgreSQLParserSMALLINT, PostgreSQLParserSUBSTRING, PostgreSQLParserTIME, PostgreSQLParserTIMESTAMP, PostgreSQLParserTREAT, PostgreSQLParserTRIM, PostgreSQLParserVALUES, PostgreSQLParserVARCHAR, PostgreSQLParserXMLATTRIBUTES, PostgreSQLParserXMLCOMMENT, PostgreSQLParserXMLAGG, PostgreSQLParserXML_IS_WELL_FORMED, PostgreSQLParserXML_IS_WELL_FORMED_DOCUMENT, PostgreSQLParserXML_IS_WELL_FORMED_CONTENT, PostgreSQLParserXPATH, PostgreSQLParserXPATH_EXISTS, PostgreSQLParserXMLCONCAT, PostgreSQLParserXMLELEMENT, PostgreSQLParserXMLEXISTS, PostgreSQLParserXMLFOREST, PostgreSQLParserXMLPARSE, PostgreSQLParserXMLPI, PostgreSQLParserXMLROOT, PostgreSQLParserXMLSERIALIZE, PostgreSQLParserCALL, PostgreSQLParserCURRENT_P, PostgreSQLParserATTACH, PostgreSQLParserDETACH, PostgreSQLParserEXPRESSION, PostgreSQLParserGENERATED, PostgreSQLParserLOGGED, PostgreSQLParserSTORED, PostgreSQLParserINCLUDE, PostgreSQLParserROUTINE, PostgreSQLParserTRANSFORM, PostgreSQLParserIMPORT_P, PostgreSQLParserPOLICY, PostgreSQLParserMETHOD, PostgreSQLParserREFERENCING, PostgreSQLParserNEW, PostgreSQLParserOLD, PostgreSQLParserVALUE_P, PostgreSQLParserSUBSCRIPTION, PostgreSQLParserPUBLICATION, PostgreSQLParserOUT_P, PostgreSQLParserROUTINES, PostgreSQLParserSCHEMAS, PostgreSQLParserPROCEDURES, PostgreSQLParserINPUT_P, PostgreSQLParserSUPPORT, PostgreSQLParserPARALLEL, PostgreSQLParserSQL_P, PostgreSQLParserDEPENDS, PostgreSQLParserOVERRIDING, PostgreSQLParserCONFLICT, PostgreSQLParserSKIP_P, PostgreSQLParserLOCKED, PostgreSQLParserTIES, PostgreSQLParserROLLUP, PostgreSQLParserCUBE, PostgreSQLParserGROUPING, PostgreSQLParserSETS, PostgreSQLParserORDINALITY, PostgreSQLParserXMLTABLE, PostgreSQLParserCOLUMNS, PostgreSQLParserXMLNAMESPACES, PostgreSQLParserROWTYPE, PostgreSQLParserNORMALIZED, PostgreSQLParserWITHIN, PostgreSQLParserFILTER, PostgreSQLParserGROUPS, PostgreSQLParserOTHERS, PostgreSQLParserNFC, PostgreSQLParserNFD, PostgreSQLParserNFKC, PostgreSQLParserNFKD, PostgreSQLParserUESCAPE, PostgreSQLParserVIEWS, PostgreSQLParserNORMALIZE, PostgreSQLParserDUMP, PostgreSQLParserPRINT_STRICT_PARAMS, PostgreSQLParserVARIABLE_CONFLICT, PostgreSQLParserERROR, PostgreSQLParserUSE_VARIABLE, PostgreSQLParserUSE_COLUMN, PostgreSQLParserALIAS, PostgreSQLParserCONSTANT, PostgreSQLParserPERFORM, PostgreSQLParserGET, PostgreSQLParserDIAGNOSTICS, PostgreSQLParserSTACKED, PostgreSQLParserELSIF, PostgreSQLParserREVERSE, PostgreSQLParserSLICE, PostgreSQLParserEXIT, PostgreSQLParserRETURN, PostgreSQLParserQUERY, PostgreSQLParserRAISE, PostgreSQLParserSQLSTATE, PostgreSQLParserDEBUG, PostgreSQLParserLOG, PostgreSQLParserINFO, PostgreSQLParserNOTICE, PostgreSQLParserWARNING, PostgreSQLParserEXCEPTION, PostgreSQLParserASSERT, PostgreSQLParserOPEN, PostgreSQLParserABS, PostgreSQLParserCBRT, PostgreSQLParserCEIL, PostgreSQLParserCEILING, PostgreSQLParserDEGREES, PostgreSQLParserDIV, PostgreSQLParserEXP, PostgreSQLParserFACTORIAL, PostgreSQLParserFLOOR, PostgreSQLParserGCD, PostgreSQLParserLCM, PostgreSQLParserLN, PostgreSQLParserLOG10, PostgreSQLParserMIN_SCALE, PostgreSQLParserMOD, PostgreSQLParserPI, PostgreSQLParserPOWER, PostgreSQLParserRADIANS, PostgreSQLParserROUND, PostgreSQLParserSCALE, PostgreSQLParserSIGN, PostgreSQLParserSQRT, PostgreSQLParserTRIM_SCALE, PostgreSQLParserTRUNC, PostgreSQLParserWIDTH_BUCKET, PostgreSQLParserRANDOM, PostgreSQLParserSETSEED, PostgreSQLParserACOS, PostgreSQLParserACOSD, PostgreSQLParserASIN, PostgreSQLParserASIND, PostgreSQLParserATAN, PostgreSQLParserATAND, PostgreSQLParserATAN2, PostgreSQLParserATAN2D, PostgreSQLParserCOS, PostgreSQLParserCOSD, PostgreSQLParserCOT, PostgreSQLParserCOTD, PostgreSQLParserSIN, PostgreSQLParserSIND, PostgreSQLParserTAN, PostgreSQLParserTAND, PostgreSQLParserSINH, PostgreSQLParserCOSH, PostgreSQLParserTANH, PostgreSQLParserASINH, PostgreSQLParserACOSH, PostgreSQLParserATANH, PostgreSQLParserBIT_LENGTH, PostgreSQLParserCHAR_LENGTH, PostgreSQLParserCHARACTER_LENGTH, PostgreSQLParserLOWER, PostgreSQLParserOCTET_LENGTH, PostgreSQLParserUPPER, PostgreSQLParserASCII, PostgreSQLParserBTRIM, PostgreSQLParserCHR, PostgreSQLParserCONCAT, PostgreSQLParserCONCAT_WS, PostgreSQLParserFORMAT, PostgreSQLParserINITCAP, PostgreSQLParserLENGTH, PostgreSQLParserLPAD, PostgreSQLParserLTRIM, PostgreSQLParserMD5, PostgreSQLParserPARSE_IDENT, PostgreSQLParserPG_CLIENT_ENCODING, PostgreSQLParserQUOTE_IDENT, PostgreSQLParserQUOTE_LITERAL, PostgreSQLParserQUOTE_NULLABLE, PostgreSQLParserREGEXP_COUNT, PostgreSQLParserREGEXP_INSTR, PostgreSQLParserREGEXP_LIKE, PostgreSQLParserREGEXP_MATCH, PostgreSQLParserREGEXP_MATCHES, PostgreSQLParserREGEXP_REPLACE, PostgreSQLParserREGEXP_SPLIT_TO_ARRAY, PostgreSQLParserREGEXP_SPLIT_TO_TABLE, PostgreSQLParserREGEXP_SUBSTR, PostgreSQLParserREPEAT, PostgreSQLParserRPAD, PostgreSQLParserRTRIM, PostgreSQLParserSPLIT_PART, PostgreSQLParserSTARTS_WITH, PostgreSQLParserSTRING_TO_ARRAY, PostgreSQLParserSTRING_TO_TABLE, PostgreSQLParserSTRPOS, PostgreSQLParserSUBSTR, PostgreSQLParserTO_ASCII, PostgreSQLParserTO_HEX, PostgreSQLParserTRANSLATE, PostgreSQLParserUNISTR, PostgreSQLParserAGE, PostgreSQLParserCLOCK_TIMESTAMP, PostgreSQLParserDATE_BIN, PostgreSQLParserDATE_PART, PostgreSQLParserDATE_TRUNC, PostgreSQLParserISFINITE, PostgreSQLParserJUSTIFY_DAYS, PostgreSQLParserJUSTIFY_HOURS, PostgreSQLParserJUSTIFY_INTERVAL, PostgreSQLParserMAKE_DATE, PostgreSQLParserMAKE_INTERVAL, PostgreSQLParserMAKE_TIME, PostgreSQLParserMAKE_TIMESTAMP, PostgreSQLParserMAKE_TIMESTAMPTZ, PostgreSQLParserNOW, PostgreSQLParserSTATEMENT_TIMESTAMP, PostgreSQLParserTIMEOFDAY, PostgreSQLParserTRANSACTION_TIMESTAMP, PostgreSQLParserTO_TIMESTAMP, PostgreSQLParserTO_CHAR, PostgreSQLParserTO_DATE, PostgreSQLParserTO_NUMBER, PostgreSQLParserIdentifier, PostgreSQLParserQuotedIdentifier, PostgreSQLParserUnicodeQuotedIdentifier, PostgreSQLParserPLSQLVARIABLENAME, PostgreSQLParserPLSQLIDENTIFIER:
			{
				p.SetState(8426)
				p.Qualified_name()
			}

		case PostgreSQLParserOPEN_PAREN:
			{
				p.SetState(8427)
				p.Match(PostgreSQLParserOPEN_PAREN)
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}
			{
				p.SetState(8428)
				p.Qualified_name()
			}
			{
				p.SetState(8429)
				p.Match(PostgreSQLParserCLOSE_PAREN)
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}

		default:
			p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
			goto errorExit
		}

	default:
		p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IRelation_expr_listContext is an interface to support dynamic dispatch.
type IRelation_expr_listContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	AllRelation_expr() []IRelation_exprContext
	Relation_expr(i int) IRelation_exprContext
	AllCOMMA() []antlr.TerminalNode
	COMMA(i int) antlr.TerminalNode

	// IsRelation_expr_listContext differentiates from other interfaces.
	IsRelation_expr_listContext()
}

type Relation_expr_listContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyRelation_expr_listContext() *Relation_expr_listContext {
	var p = new(Relation_expr_listContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_relation_expr_list
	return p
}

func InitEmptyRelation_expr_listContext(p *Relation_expr_listContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_relation_expr_list
}

func (*Relation_expr_listContext) IsRelation_expr_listContext() {}

func NewRelation_expr_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Relation_expr_listContext {
	var p = new(Relation_expr_listContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_relation_expr_list

	return p
}

func (s *Relation_expr_listContext) GetParser() antlr.Parser { return s.parser }

func (s *Relation_expr_listContext) AllRelation_expr() []IRelation_exprContext {
	children := s.GetChildren()
	len := 0
	for _, ctx := range children {
		if _, ok := ctx.(IRelation_exprContext); ok {
			len++
		}
	}

	tst := make([]IRelation_exprContext, len)
	i := 0
	for _, ctx := range children {
		if t, ok := ctx.(IRelation_exprContext); ok {
			tst[i] = t.(IRelation_exprContext)
			i++
		}
	}

	return tst
}

func (s *Relation_expr_listContext) Relation_expr(i int) IRelation_exprContext {
	var t antlr.RuleContext
	j := 0
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IRelation_exprContext); ok {
			if j == i {
				t = ctx.(antlr.RuleContext)
				break
			}
			j++
		}
	}

	if t == nil {
		return nil
	}

	return t.(IRelation_exprContext)
}

func (s *Relation_expr_listContext) AllCOMMA() []antlr.TerminalNode {
	return s.GetTokens(PostgreSQLParserCOMMA)
}

func (s *Relation_expr_listContext) COMMA(i int) antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCOMMA, i)
}

func (s *Relation_expr_listContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Relation_expr_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Relation_expr_listContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterRelation_expr_list(s)
	}
}

func (s *Relation_expr_listContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitRelation_expr_list(s)
	}
}

func (s *Relation_expr_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitRelation_expr_list(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Relation_expr_list() (localctx IRelation_expr_listContext) {
	localctx = NewRelation_expr_listContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1076, PostgreSQLParserRULE_relation_expr_list)
	var _la int

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(8435)
		p.Relation_expr()
	}
	p.SetState(8440)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}
	_la = p.GetTokenStream().LA(1)

	for _la == PostgreSQLParserCOMMA {
		{
			p.SetState(8436)
			p.Match(PostgreSQLParserCOMMA)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(8437)
			p.Relation_expr()
		}

		p.SetState(8442)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}
		_la = p.GetTokenStream().LA(1)
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IRelation_expr_opt_aliasContext is an interface to support dynamic dispatch.
type IRelation_expr_opt_aliasContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Relation_expr() IRelation_exprContext
	Colid() IColidContext
	AS() antlr.TerminalNode

	// IsRelation_expr_opt_aliasContext differentiates from other interfaces.
	IsRelation_expr_opt_aliasContext()
}

type Relation_expr_opt_aliasContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyRelation_expr_opt_aliasContext() *Relation_expr_opt_aliasContext {
	var p = new(Relation_expr_opt_aliasContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_relation_expr_opt_alias
	return p
}

func InitEmptyRelation_expr_opt_aliasContext(p *Relation_expr_opt_aliasContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_relation_expr_opt_alias
}

func (*Relation_expr_opt_aliasContext) IsRelation_expr_opt_aliasContext() {}

func NewRelation_expr_opt_aliasContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Relation_expr_opt_aliasContext {
	var p = new(Relation_expr_opt_aliasContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_relation_expr_opt_alias

	return p
}

func (s *Relation_expr_opt_aliasContext) GetParser() antlr.Parser { return s.parser }

func (s *Relation_expr_opt_aliasContext) Relation_expr() IRelation_exprContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IRelation_exprContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IRelation_exprContext)
}

func (s *Relation_expr_opt_aliasContext) Colid() IColidContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IColidContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IColidContext)
}

func (s *Relation_expr_opt_aliasContext) AS() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserAS, 0)
}

func (s *Relation_expr_opt_aliasContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Relation_expr_opt_aliasContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Relation_expr_opt_aliasContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterRelation_expr_opt_alias(s)
	}
}

func (s *Relation_expr_opt_aliasContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitRelation_expr_opt_alias(s)
	}
}

func (s *Relation_expr_opt_aliasContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitRelation_expr_opt_alias(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Relation_expr_opt_alias() (localctx IRelation_expr_opt_aliasContext) {
	localctx = NewRelation_expr_opt_aliasContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1078, PostgreSQLParserRULE_relation_expr_opt_alias)
	var _la int

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(8443)
		p.Relation_expr()
	}
	p.SetState(8448)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 495, p.GetParserRuleContext()) == 1 {
		p.SetState(8445)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}
		_la = p.GetTokenStream().LA(1)

		if _la == PostgreSQLParserAS {
			{
				p.SetState(8444)
				p.Match(PostgreSQLParserAS)
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}

		}
		{
			p.SetState(8447)
			p.Colid()
		}

	} else if p.HasError() { // JIM
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// ITablesample_clauseContext is an interface to support dynamic dispatch.
type ITablesample_clauseContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	TABLESAMPLE() antlr.TerminalNode
	Func_name() IFunc_nameContext
	OPEN_PAREN() antlr.TerminalNode
	Expr_list() IExpr_listContext
	CLOSE_PAREN() antlr.TerminalNode
	Opt_repeatable_clause() IOpt_repeatable_clauseContext

	// IsTablesample_clauseContext differentiates from other interfaces.
	IsTablesample_clauseContext()
}

type Tablesample_clauseContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyTablesample_clauseContext() *Tablesample_clauseContext {
	var p = new(Tablesample_clauseContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_tablesample_clause
	return p
}

func InitEmptyTablesample_clauseContext(p *Tablesample_clauseContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_tablesample_clause
}

func (*Tablesample_clauseContext) IsTablesample_clauseContext() {}

func NewTablesample_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Tablesample_clauseContext {
	var p = new(Tablesample_clauseContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_tablesample_clause

	return p
}

func (s *Tablesample_clauseContext) GetParser() antlr.Parser { return s.parser }

func (s *Tablesample_clauseContext) TABLESAMPLE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserTABLESAMPLE, 0)
}

func (s *Tablesample_clauseContext) Func_name() IFunc_nameContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IFunc_nameContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IFunc_nameContext)
}

func (s *Tablesample_clauseContext) OPEN_PAREN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserOPEN_PAREN, 0)
}

func (s *Tablesample_clauseContext) Expr_list() IExpr_listContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IExpr_listContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IExpr_listContext)
}

func (s *Tablesample_clauseContext) CLOSE_PAREN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCLOSE_PAREN, 0)
}

func (s *Tablesample_clauseContext) Opt_repeatable_clause() IOpt_repeatable_clauseContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOpt_repeatable_clauseContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOpt_repeatable_clauseContext)
}

func (s *Tablesample_clauseContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Tablesample_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Tablesample_clauseContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterTablesample_clause(s)
	}
}

func (s *Tablesample_clauseContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitTablesample_clause(s)
	}
}

func (s *Tablesample_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitTablesample_clause(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Tablesample_clause() (localctx ITablesample_clauseContext) {
	localctx = NewTablesample_clauseContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1080, PostgreSQLParserRULE_tablesample_clause)
	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(8450)
		p.Match(PostgreSQLParserTABLESAMPLE)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(8451)
		p.Func_name()
	}
	{
		p.SetState(8452)
		p.Match(PostgreSQLParserOPEN_PAREN)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(8453)
		p.Expr_list()
	}
	{
		p.SetState(8454)
		p.Match(PostgreSQLParserCLOSE_PAREN)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(8455)
		p.Opt_repeatable_clause()
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IOpt_repeatable_clauseContext is an interface to support dynamic dispatch.
type IOpt_repeatable_clauseContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	REPEATABLE() antlr.TerminalNode
	OPEN_PAREN() antlr.TerminalNode
	A_expr() IA_exprContext
	CLOSE_PAREN() antlr.TerminalNode

	// IsOpt_repeatable_clauseContext differentiates from other interfaces.
	IsOpt_repeatable_clauseContext()
}

type Opt_repeatable_clauseContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyOpt_repeatable_clauseContext() *Opt_repeatable_clauseContext {
	var p = new(Opt_repeatable_clauseContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opt_repeatable_clause
	return p
}

func InitEmptyOpt_repeatable_clauseContext(p *Opt_repeatable_clauseContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opt_repeatable_clause
}

func (*Opt_repeatable_clauseContext) IsOpt_repeatable_clauseContext() {}

func NewOpt_repeatable_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_repeatable_clauseContext {
	var p = new(Opt_repeatable_clauseContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_opt_repeatable_clause

	return p
}

func (s *Opt_repeatable_clauseContext) GetParser() antlr.Parser { return s.parser }

func (s *Opt_repeatable_clauseContext) REPEATABLE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserREPEATABLE, 0)
}

func (s *Opt_repeatable_clauseContext) OPEN_PAREN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserOPEN_PAREN, 0)
}

func (s *Opt_repeatable_clauseContext) A_expr() IA_exprContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IA_exprContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IA_exprContext)
}

func (s *Opt_repeatable_clauseContext) CLOSE_PAREN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCLOSE_PAREN, 0)
}

func (s *Opt_repeatable_clauseContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Opt_repeatable_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Opt_repeatable_clauseContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterOpt_repeatable_clause(s)
	}
}

func (s *Opt_repeatable_clauseContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitOpt_repeatable_clause(s)
	}
}

func (s *Opt_repeatable_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitOpt_repeatable_clause(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Opt_repeatable_clause() (localctx IOpt_repeatable_clauseContext) {
	localctx = NewOpt_repeatable_clauseContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1082, PostgreSQLParserRULE_opt_repeatable_clause)
	p.SetState(8463)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetTokenStream().LA(1) {
	case PostgreSQLParserREPEATABLE:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(8457)
			p.Match(PostgreSQLParserREPEATABLE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(8458)
			p.Match(PostgreSQLParserOPEN_PAREN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(8459)
			p.A_expr()
		}
		{
			p.SetState(8460)
			p.Match(PostgreSQLParserCLOSE_PAREN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case PostgreSQLParserEOF, PostgreSQLParserOPEN_PAREN, PostgreSQLParserCLOSE_PAREN, PostgreSQLParserCOMMA, PostgreSQLParserSEMI, PostgreSQLParserANALYSE, PostgreSQLParserANALYZE, PostgreSQLParserCREATE, PostgreSQLParserDO, PostgreSQLParserEXCEPT, PostgreSQLParserFETCH, PostgreSQLParserFOR, PostgreSQLParserGRANT, PostgreSQLParserGROUP_P, PostgreSQLParserHAVING, PostgreSQLParserINTERSECT, PostgreSQLParserINTO, PostgreSQLParserLIMIT, PostgreSQLParserOFFSET, PostgreSQLParserON, PostgreSQLParserORDER, PostgreSQLParserRETURNING, PostgreSQLParserSELECT, PostgreSQLParserTABLE, PostgreSQLParserTHEN, PostgreSQLParserUNION, PostgreSQLParserUSING, PostgreSQLParserWHEN, PostgreSQLParserWHERE, PostgreSQLParserWINDOW, PostgreSQLParserWITH, PostgreSQLParserCROSS, PostgreSQLParserFULL, PostgreSQLParserINNER_P, PostgreSQLParserJOIN, PostgreSQLParserLEFT, PostgreSQLParserNATURAL, PostgreSQLParserRIGHT, PostgreSQLParserABORT_P, PostgreSQLParserALTER, PostgreSQLParserBEGIN_P, PostgreSQLParserCHECKPOINT, PostgreSQLParserCLOSE, PostgreSQLParserCLUSTER, PostgreSQLParserCOMMENT, PostgreSQLParserCOMMIT, PostgreSQLParserCOPY, PostgreSQLParserDEALLOCATE, PostgreSQLParserDECLARE, PostgreSQLParserDELETE_P, PostgreSQLParserDISCARD, PostgreSQLParserDROP, PostgreSQLParserEXECUTE, PostgreSQLParserEXPLAIN, PostgreSQLParserINSERT, PostgreSQLParserLISTEN, PostgreSQLParserLOAD, PostgreSQLParserLOCK_P, PostgreSQLParserMERGE, PostgreSQLParserMOVE, PostgreSQLParserNOTIFY, PostgreSQLParserPREPARE, PostgreSQLParserREASSIGN, PostgreSQLParserREFRESH, PostgreSQLParserREINDEX, PostgreSQLParserRELEASE, PostgreSQLParserRESET, PostgreSQLParserREVOKE, PostgreSQLParserROLLBACK, PostgreSQLParserSAVEPOINT, PostgreSQLParserSECURITY, PostgreSQLParserSET, PostgreSQLParserSHOW, PostgreSQLParserSTART, PostgreSQLParserTRUNCATE, PostgreSQLParserUNLISTEN, PostgreSQLParserUPDATE, PostgreSQLParserVACUUM, PostgreSQLParserVALUES, PostgreSQLParserCALL, PostgreSQLParserIMPORT_P, PostgreSQLParserEND_P, PostgreSQLParserLOOP, PostgreSQLParserMetaCommand:
		p.EnterOuterAlt(localctx, 2)

	default:
		p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IFunc_tableContext is an interface to support dynamic dispatch.
type IFunc_tableContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Func_expr_windowless() IFunc_expr_windowlessContext
	Opt_ordinality() IOpt_ordinalityContext
	ROWS() antlr.TerminalNode
	FROM() antlr.TerminalNode
	OPEN_PAREN() antlr.TerminalNode
	Rowsfrom_list() IRowsfrom_listContext
	CLOSE_PAREN() antlr.TerminalNode

	// IsFunc_tableContext differentiates from other interfaces.
	IsFunc_tableContext()
}

type Func_tableContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyFunc_tableContext() *Func_tableContext {
	var p = new(Func_tableContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_func_table
	return p
}

func InitEmptyFunc_tableContext(p *Func_tableContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_func_table
}

func (*Func_tableContext) IsFunc_tableContext() {}

func NewFunc_tableContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Func_tableContext {
	var p = new(Func_tableContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_func_table

	return p
}

func (s *Func_tableContext) GetParser() antlr.Parser { return s.parser }

func (s *Func_tableContext) Func_expr_windowless() IFunc_expr_windowlessContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IFunc_expr_windowlessContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IFunc_expr_windowlessContext)
}

func (s *Func_tableContext) Opt_ordinality() IOpt_ordinalityContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOpt_ordinalityContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOpt_ordinalityContext)
}

func (s *Func_tableContext) ROWS() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserROWS, 0)
}

func (s *Func_tableContext) FROM() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserFROM, 0)
}

func (s *Func_tableContext) OPEN_PAREN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserOPEN_PAREN, 0)
}

func (s *Func_tableContext) Rowsfrom_list() IRowsfrom_listContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IRowsfrom_listContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IRowsfrom_listContext)
}

func (s *Func_tableContext) CLOSE_PAREN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCLOSE_PAREN, 0)
}

func (s *Func_tableContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Func_tableContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Func_tableContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterFunc_table(s)
	}
}

func (s *Func_tableContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitFunc_table(s)
	}
}

func (s *Func_tableContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitFunc_table(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Func_table() (localctx IFunc_tableContext) {
	localctx = NewFunc_tableContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1084, PostgreSQLParserRULE_func_table)
	p.SetState(8475)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 497, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(8465)
			p.Func_expr_windowless()
		}
		{
			p.SetState(8466)
			p.Opt_ordinality()
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(8468)
			p.Match(PostgreSQLParserROWS)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(8469)
			p.Match(PostgreSQLParserFROM)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(8470)
			p.Match(PostgreSQLParserOPEN_PAREN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(8471)
			p.Rowsfrom_list()
		}
		{
			p.SetState(8472)
			p.Match(PostgreSQLParserCLOSE_PAREN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(8473)
			p.Opt_ordinality()
		}

	case antlr.ATNInvalidAltNumber:
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IRowsfrom_itemContext is an interface to support dynamic dispatch.
type IRowsfrom_itemContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Func_expr_windowless() IFunc_expr_windowlessContext
	Opt_col_def_list() IOpt_col_def_listContext

	// IsRowsfrom_itemContext differentiates from other interfaces.
	IsRowsfrom_itemContext()
}

type Rowsfrom_itemContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyRowsfrom_itemContext() *Rowsfrom_itemContext {
	var p = new(Rowsfrom_itemContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_rowsfrom_item
	return p
}

func InitEmptyRowsfrom_itemContext(p *Rowsfrom_itemContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_rowsfrom_item
}

func (*Rowsfrom_itemContext) IsRowsfrom_itemContext() {}

func NewRowsfrom_itemContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Rowsfrom_itemContext {
	var p = new(Rowsfrom_itemContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_rowsfrom_item

	return p
}

func (s *Rowsfrom_itemContext) GetParser() antlr.Parser { return s.parser }

func (s *Rowsfrom_itemContext) Func_expr_windowless() IFunc_expr_windowlessContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IFunc_expr_windowlessContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IFunc_expr_windowlessContext)
}

func (s *Rowsfrom_itemContext) Opt_col_def_list() IOpt_col_def_listContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOpt_col_def_listContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOpt_col_def_listContext)
}

func (s *Rowsfrom_itemContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Rowsfrom_itemContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Rowsfrom_itemContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterRowsfrom_item(s)
	}
}

func (s *Rowsfrom_itemContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitRowsfrom_item(s)
	}
}

func (s *Rowsfrom_itemContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitRowsfrom_item(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Rowsfrom_item() (localctx IRowsfrom_itemContext) {
	localctx = NewRowsfrom_itemContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1086, PostgreSQLParserRULE_rowsfrom_item)
	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(8477)
		p.Func_expr_windowless()
	}
	{
		p.SetState(8478)
		p.Opt_col_def_list()
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IRowsfrom_listContext is an interface to support dynamic dispatch.
type IRowsfrom_listContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	AllRowsfrom_item() []IRowsfrom_itemContext
	Rowsfrom_item(i int) IRowsfrom_itemContext
	AllCOMMA() []antlr.TerminalNode
	COMMA(i int) antlr.TerminalNode

	// IsRowsfrom_listContext differentiates from other interfaces.
	IsRowsfrom_listContext()
}

type Rowsfrom_listContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyRowsfrom_listContext() *Rowsfrom_listContext {
	var p = new(Rowsfrom_listContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_rowsfrom_list
	return p
}

func InitEmptyRowsfrom_listContext(p *Rowsfrom_listContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_rowsfrom_list
}

func (*Rowsfrom_listContext) IsRowsfrom_listContext() {}

func NewRowsfrom_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Rowsfrom_listContext {
	var p = new(Rowsfrom_listContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_rowsfrom_list

	return p
}

func (s *Rowsfrom_listContext) GetParser() antlr.Parser { return s.parser }

func (s *Rowsfrom_listContext) AllRowsfrom_item() []IRowsfrom_itemContext {
	children := s.GetChildren()
	len := 0
	for _, ctx := range children {
		if _, ok := ctx.(IRowsfrom_itemContext); ok {
			len++
		}
	}

	tst := make([]IRowsfrom_itemContext, len)
	i := 0
	for _, ctx := range children {
		if t, ok := ctx.(IRowsfrom_itemContext); ok {
			tst[i] = t.(IRowsfrom_itemContext)
			i++
		}
	}

	return tst
}

func (s *Rowsfrom_listContext) Rowsfrom_item(i int) IRowsfrom_itemContext {
	var t antlr.RuleContext
	j := 0
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IRowsfrom_itemContext); ok {
			if j == i {
				t = ctx.(antlr.RuleContext)
				break
			}
			j++
		}
	}

	if t == nil {
		return nil
	}

	return t.(IRowsfrom_itemContext)
}

func (s *Rowsfrom_listContext) AllCOMMA() []antlr.TerminalNode {
	return s.GetTokens(PostgreSQLParserCOMMA)
}

func (s *Rowsfrom_listContext) COMMA(i int) antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCOMMA, i)
}

func (s *Rowsfrom_listContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Rowsfrom_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Rowsfrom_listContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterRowsfrom_list(s)
	}
}

func (s *Rowsfrom_listContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitRowsfrom_list(s)
	}
}

func (s *Rowsfrom_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitRowsfrom_list(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Rowsfrom_list() (localctx IRowsfrom_listContext) {
	localctx = NewRowsfrom_listContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1088, PostgreSQLParserRULE_rowsfrom_list)
	var _la int

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(8480)
		p.Rowsfrom_item()
	}
	p.SetState(8485)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}
	_la = p.GetTokenStream().LA(1)

	for _la == PostgreSQLParserCOMMA {
		{
			p.SetState(8481)
			p.Match(PostgreSQLParserCOMMA)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(8482)
			p.Rowsfrom_item()
		}

		p.SetState(8487)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}
		_la = p.GetTokenStream().LA(1)
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IOpt_col_def_listContext is an interface to support dynamic dispatch.
type IOpt_col_def_listContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	AS() antlr.TerminalNode
	OPEN_PAREN() antlr.TerminalNode
	Tablefuncelementlist() ITablefuncelementlistContext
	CLOSE_PAREN() antlr.TerminalNode

	// IsOpt_col_def_listContext differentiates from other interfaces.
	IsOpt_col_def_listContext()
}

type Opt_col_def_listContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyOpt_col_def_listContext() *Opt_col_def_listContext {
	var p = new(Opt_col_def_listContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opt_col_def_list
	return p
}

func InitEmptyOpt_col_def_listContext(p *Opt_col_def_listContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opt_col_def_list
}

func (*Opt_col_def_listContext) IsOpt_col_def_listContext() {}

func NewOpt_col_def_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_col_def_listContext {
	var p = new(Opt_col_def_listContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_opt_col_def_list

	return p
}

func (s *Opt_col_def_listContext) GetParser() antlr.Parser { return s.parser }

func (s *Opt_col_def_listContext) AS() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserAS, 0)
}

func (s *Opt_col_def_listContext) OPEN_PAREN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserOPEN_PAREN, 0)
}

func (s *Opt_col_def_listContext) Tablefuncelementlist() ITablefuncelementlistContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ITablefuncelementlistContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ITablefuncelementlistContext)
}

func (s *Opt_col_def_listContext) CLOSE_PAREN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCLOSE_PAREN, 0)
}

func (s *Opt_col_def_listContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Opt_col_def_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Opt_col_def_listContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterOpt_col_def_list(s)
	}
}

func (s *Opt_col_def_listContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitOpt_col_def_list(s)
	}
}

func (s *Opt_col_def_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitOpt_col_def_list(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Opt_col_def_list() (localctx IOpt_col_def_listContext) {
	localctx = NewOpt_col_def_listContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1090, PostgreSQLParserRULE_opt_col_def_list)
	p.SetState(8494)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetTokenStream().LA(1) {
	case PostgreSQLParserAS:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(8488)
			p.Match(PostgreSQLParserAS)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(8489)
			p.Match(PostgreSQLParserOPEN_PAREN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(8490)
			p.Tablefuncelementlist()
		}
		{
			p.SetState(8491)
			p.Match(PostgreSQLParserCLOSE_PAREN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case PostgreSQLParserCLOSE_PAREN, PostgreSQLParserCOMMA:
		p.EnterOuterAlt(localctx, 2)

	default:
		p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IOpt_ordinalityContext is an interface to support dynamic dispatch.
type IOpt_ordinalityContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	WITH() antlr.TerminalNode
	ORDINALITY() antlr.TerminalNode

	// IsOpt_ordinalityContext differentiates from other interfaces.
	IsOpt_ordinalityContext()
}

type Opt_ordinalityContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyOpt_ordinalityContext() *Opt_ordinalityContext {
	var p = new(Opt_ordinalityContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opt_ordinality
	return p
}

func InitEmptyOpt_ordinalityContext(p *Opt_ordinalityContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opt_ordinality
}

func (*Opt_ordinalityContext) IsOpt_ordinalityContext() {}

func NewOpt_ordinalityContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_ordinalityContext {
	var p = new(Opt_ordinalityContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_opt_ordinality

	return p
}

func (s *Opt_ordinalityContext) GetParser() antlr.Parser { return s.parser }

func (s *Opt_ordinalityContext) WITH() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserWITH, 0)
}

func (s *Opt_ordinalityContext) ORDINALITY() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserORDINALITY, 0)
}

func (s *Opt_ordinalityContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Opt_ordinalityContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Opt_ordinalityContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterOpt_ordinality(s)
	}
}

func (s *Opt_ordinalityContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitOpt_ordinality(s)
	}
}

func (s *Opt_ordinalityContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitOpt_ordinality(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Opt_ordinality() (localctx IOpt_ordinalityContext) {
	localctx = NewOpt_ordinalityContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1092, PostgreSQLParserRULE_opt_ordinality)
	p.SetState(8499)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 500, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(8496)
			p.Match(PostgreSQLParserWITH)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(8497)
			p.Match(PostgreSQLParserORDINALITY)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)

	case antlr.ATNInvalidAltNumber:
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IWhere_clauseContext is an interface to support dynamic dispatch.
type IWhere_clauseContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	WHERE() antlr.TerminalNode
	A_expr() IA_exprContext

	// IsWhere_clauseContext differentiates from other interfaces.
	IsWhere_clauseContext()
}

type Where_clauseContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyWhere_clauseContext() *Where_clauseContext {
	var p = new(Where_clauseContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_where_clause
	return p
}

func InitEmptyWhere_clauseContext(p *Where_clauseContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_where_clause
}

func (*Where_clauseContext) IsWhere_clauseContext() {}

func NewWhere_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Where_clauseContext {
	var p = new(Where_clauseContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_where_clause

	return p
}

func (s *Where_clauseContext) GetParser() antlr.Parser { return s.parser }

func (s *Where_clauseContext) WHERE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserWHERE, 0)
}

func (s *Where_clauseContext) A_expr() IA_exprContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IA_exprContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IA_exprContext)
}

func (s *Where_clauseContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Where_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Where_clauseContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterWhere_clause(s)
	}
}

func (s *Where_clauseContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitWhere_clause(s)
	}
}

func (s *Where_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitWhere_clause(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Where_clause() (localctx IWhere_clauseContext) {
	localctx = NewWhere_clauseContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1094, PostgreSQLParserRULE_where_clause)
	p.SetState(8504)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetTokenStream().LA(1) {
	case PostgreSQLParserWHERE:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(8501)
			p.Match(PostgreSQLParserWHERE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(8502)
			p.A_expr()
		}

	case PostgreSQLParserEOF, PostgreSQLParserOPEN_PAREN, PostgreSQLParserCLOSE_PAREN, PostgreSQLParserCOMMA, PostgreSQLParserSEMI, PostgreSQLParserANALYSE, PostgreSQLParserANALYZE, PostgreSQLParserCREATE, PostgreSQLParserDO, PostgreSQLParserEXCEPT, PostgreSQLParserFETCH, PostgreSQLParserFOR, PostgreSQLParserGRANT, PostgreSQLParserGROUP_P, PostgreSQLParserHAVING, PostgreSQLParserINTERSECT, PostgreSQLParserINTO, PostgreSQLParserLIMIT, PostgreSQLParserOFFSET, PostgreSQLParserON, PostgreSQLParserORDER, PostgreSQLParserRETURNING, PostgreSQLParserSELECT, PostgreSQLParserTABLE, PostgreSQLParserTHEN, PostgreSQLParserUNION, PostgreSQLParserUSING, PostgreSQLParserWHEN, PostgreSQLParserWINDOW, PostgreSQLParserWITH, PostgreSQLParserABORT_P, PostgreSQLParserALTER, PostgreSQLParserBEGIN_P, PostgreSQLParserCHECKPOINT, PostgreSQLParserCLOSE, PostgreSQLParserCLUSTER, PostgreSQLParserCOMMENT, PostgreSQLParserCOMMIT, PostgreSQLParserCOPY, PostgreSQLParserDEALLOCATE, PostgreSQLParserDECLARE, PostgreSQLParserDELETE_P, PostgreSQLParserDISCARD, PostgreSQLParserDROP, PostgreSQLParserEXECUTE, PostgreSQLParserEXPLAIN, PostgreSQLParserINSERT, PostgreSQLParserLISTEN, PostgreSQLParserLOAD, PostgreSQLParserLOCK_P, PostgreSQLParserMERGE, PostgreSQLParserMOVE, PostgreSQLParserNOTIFY, PostgreSQLParserPREPARE, PostgreSQLParserREASSIGN, PostgreSQLParserREFRESH, PostgreSQLParserREINDEX, PostgreSQLParserRELEASE, PostgreSQLParserRESET, PostgreSQLParserREVOKE, PostgreSQLParserROLLBACK, PostgreSQLParserSAVEPOINT, PostgreSQLParserSECURITY, PostgreSQLParserSET, PostgreSQLParserSHOW, PostgreSQLParserSTART, PostgreSQLParserTRUNCATE, PostgreSQLParserUNLISTEN, PostgreSQLParserUPDATE, PostgreSQLParserVACUUM, PostgreSQLParserVALUES, PostgreSQLParserCALL, PostgreSQLParserIMPORT_P, PostgreSQLParserEND_P, PostgreSQLParserLOOP, PostgreSQLParserMetaCommand:
		p.EnterOuterAlt(localctx, 2)

	default:
		p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IWhere_or_current_clauseContext is an interface to support dynamic dispatch.
type IWhere_or_current_clauseContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	WHERE() antlr.TerminalNode
	CURRENT_P() antlr.TerminalNode
	OF() antlr.TerminalNode
	Cursor_name() ICursor_nameContext
	A_expr() IA_exprContext

	// IsWhere_or_current_clauseContext differentiates from other interfaces.
	IsWhere_or_current_clauseContext()
}

type Where_or_current_clauseContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyWhere_or_current_clauseContext() *Where_or_current_clauseContext {
	var p = new(Where_or_current_clauseContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_where_or_current_clause
	return p
}

func InitEmptyWhere_or_current_clauseContext(p *Where_or_current_clauseContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_where_or_current_clause
}

func (*Where_or_current_clauseContext) IsWhere_or_current_clauseContext() {}

func NewWhere_or_current_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Where_or_current_clauseContext {
	var p = new(Where_or_current_clauseContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_where_or_current_clause

	return p
}

func (s *Where_or_current_clauseContext) GetParser() antlr.Parser { return s.parser }

func (s *Where_or_current_clauseContext) WHERE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserWHERE, 0)
}

func (s *Where_or_current_clauseContext) CURRENT_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCURRENT_P, 0)
}

func (s *Where_or_current_clauseContext) OF() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserOF, 0)
}

func (s *Where_or_current_clauseContext) Cursor_name() ICursor_nameContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ICursor_nameContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ICursor_nameContext)
}

func (s *Where_or_current_clauseContext) A_expr() IA_exprContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IA_exprContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IA_exprContext)
}

func (s *Where_or_current_clauseContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Where_or_current_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Where_or_current_clauseContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterWhere_or_current_clause(s)
	}
}

func (s *Where_or_current_clauseContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitWhere_or_current_clause(s)
	}
}

func (s *Where_or_current_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitWhere_or_current_clause(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Where_or_current_clause() (localctx IWhere_or_current_clauseContext) {
	localctx = NewWhere_or_current_clauseContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1096, PostgreSQLParserRULE_where_or_current_clause)
	p.SetState(8514)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetTokenStream().LA(1) {
	case PostgreSQLParserWHERE:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(8506)
			p.Match(PostgreSQLParserWHERE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		p.SetState(8511)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}

		switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 502, p.GetParserRuleContext()) {
		case 1:
			{
				p.SetState(8507)
				p.Match(PostgreSQLParserCURRENT_P)
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}
			{
				p.SetState(8508)
				p.Match(PostgreSQLParserOF)
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}
			{
				p.SetState(8509)
				p.Cursor_name()
			}

		case 2:
			{
				p.SetState(8510)
				p.A_expr()
			}

		case antlr.ATNInvalidAltNumber:
			goto errorExit
		}

	case PostgreSQLParserEOF, PostgreSQLParserOPEN_PAREN, PostgreSQLParserCLOSE_PAREN, PostgreSQLParserSEMI, PostgreSQLParserANALYSE, PostgreSQLParserANALYZE, PostgreSQLParserCREATE, PostgreSQLParserDO, PostgreSQLParserFETCH, PostgreSQLParserGRANT, PostgreSQLParserINTO, PostgreSQLParserRETURNING, PostgreSQLParserSELECT, PostgreSQLParserTABLE, PostgreSQLParserWITH, PostgreSQLParserABORT_P, PostgreSQLParserALTER, PostgreSQLParserBEGIN_P, PostgreSQLParserCHECKPOINT, PostgreSQLParserCLOSE, PostgreSQLParserCLUSTER, PostgreSQLParserCOMMENT, PostgreSQLParserCOMMIT, PostgreSQLParserCOPY, PostgreSQLParserDEALLOCATE, PostgreSQLParserDECLARE, PostgreSQLParserDELETE_P, PostgreSQLParserDISCARD, PostgreSQLParserDROP, PostgreSQLParserEXECUTE, PostgreSQLParserEXPLAIN, PostgreSQLParserINSERT, PostgreSQLParserLISTEN, PostgreSQLParserLOAD, PostgreSQLParserLOCK_P, PostgreSQLParserMERGE, PostgreSQLParserMOVE, PostgreSQLParserNOTIFY, PostgreSQLParserPREPARE, PostgreSQLParserREASSIGN, PostgreSQLParserREFRESH, PostgreSQLParserREINDEX, PostgreSQLParserRELEASE, PostgreSQLParserRESET, PostgreSQLParserREVOKE, PostgreSQLParserROLLBACK, PostgreSQLParserSAVEPOINT, PostgreSQLParserSECURITY, PostgreSQLParserSET, PostgreSQLParserSHOW, PostgreSQLParserSTART, PostgreSQLParserTRUNCATE, PostgreSQLParserUNLISTEN, PostgreSQLParserUPDATE, PostgreSQLParserVACUUM, PostgreSQLParserVALUES, PostgreSQLParserCALL, PostgreSQLParserIMPORT_P, PostgreSQLParserEND_P, PostgreSQLParserLOOP, PostgreSQLParserMetaCommand:
		p.EnterOuterAlt(localctx, 2)

	default:
		p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IOpttablefuncelementlistContext is an interface to support dynamic dispatch.
type IOpttablefuncelementlistContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Tablefuncelementlist() ITablefuncelementlistContext

	// IsOpttablefuncelementlistContext differentiates from other interfaces.
	IsOpttablefuncelementlistContext()
}

type OpttablefuncelementlistContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyOpttablefuncelementlistContext() *OpttablefuncelementlistContext {
	var p = new(OpttablefuncelementlistContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opttablefuncelementlist
	return p
}

func InitEmptyOpttablefuncelementlistContext(p *OpttablefuncelementlistContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opttablefuncelementlist
}

func (*OpttablefuncelementlistContext) IsOpttablefuncelementlistContext() {}

func NewOpttablefuncelementlistContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *OpttablefuncelementlistContext {
	var p = new(OpttablefuncelementlistContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_opttablefuncelementlist

	return p
}

func (s *OpttablefuncelementlistContext) GetParser() antlr.Parser { return s.parser }

func (s *OpttablefuncelementlistContext) Tablefuncelementlist() ITablefuncelementlistContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ITablefuncelementlistContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ITablefuncelementlistContext)
}

func (s *OpttablefuncelementlistContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *OpttablefuncelementlistContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *OpttablefuncelementlistContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterOpttablefuncelementlist(s)
	}
}

func (s *OpttablefuncelementlistContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitOpttablefuncelementlist(s)
	}
}

func (s *OpttablefuncelementlistContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitOpttablefuncelementlist(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Opttablefuncelementlist() (localctx IOpttablefuncelementlistContext) {
	localctx = NewOpttablefuncelementlistContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1098, PostgreSQLParserRULE_opttablefuncelementlist)
	p.SetState(8518)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetTokenStream().LA(1) {
	case PostgreSQLParserAND, PostgreSQLParserARRAY, PostgreSQLParserCOLLATE, PostgreSQLParserCOLUMN, PostgreSQLParserCONSTRAINT, PostgreSQLParserDEFAULT, PostgreSQLParserDO, PostgreSQLParserFETCH, PostgreSQLParserTABLE, PostgreSQLParserIS, PostgreSQLParserLEFT, PostgreSQLParserOUTER_P, PostgreSQLParserOVER, PostgreSQLParserRIGHT, PostgreSQLParserABORT_P, PostgreSQLParserABSOLUTE_P, PostgreSQLParserACCESS, PostgreSQLParserACTION, PostgreSQLParserADD_P, PostgreSQLParserADMIN, PostgreSQLParserAFTER, PostgreSQLParserAGGREGATE, PostgreSQLParserALSO, PostgreSQLParserALTER, PostgreSQLParserALWAYS, PostgreSQLParserASSERTION, PostgreSQLParserASSIGNMENT, PostgreSQLParserAT, PostgreSQLParserATTRIBUTE, PostgreSQLParserBACKWARD, PostgreSQLParserBEFORE, PostgreSQLParserBEGIN_P, PostgreSQLParserBY, PostgreSQLParserCACHE, PostgreSQLParserCALLED, PostgreSQLParserCASCADE, PostgreSQLParserCASCADED, PostgreSQLParserCATALOG, PostgreSQLParserCHAIN, PostgreSQLParserCHARACTERISTICS, PostgreSQLParserCHECKPOINT, PostgreSQLParserCLASS, PostgreSQLParserCLOSE, PostgreSQLParserCLUSTER, PostgreSQLParserCOMMENT, PostgreSQLParserCOMMENTS, PostgreSQLParserCOMMIT, PostgreSQLParserCOMMITTED, PostgreSQLParserCONFIGURATION, PostgreSQLParserCONNECTION, PostgreSQLParserCONSTRAINTS, PostgreSQLParserCONTENT_P, PostgreSQLParserCONTINUE_P, PostgreSQLParserCONVERSION_P, PostgreSQLParserCOPY, PostgreSQLParserCOST, PostgreSQLParserCSV, PostgreSQLParserCURSOR, PostgreSQLParserCYCLE, PostgreSQLParserDATA_P, PostgreSQLParserDATABASE, PostgreSQLParserDAY_P, PostgreSQLParserDEALLOCATE, PostgreSQLParserDECLARE, PostgreSQLParserDEFAULTS, PostgreSQLParserDEFERRED, PostgreSQLParserDEFINER, PostgreSQLParserDELETE_P, PostgreSQLParserDELIMITER, PostgreSQLParserDELIMITERS, PostgreSQLParserDICTIONARY, PostgreSQLParserDISABLE_P, PostgreSQLParserDISCARD, PostgreSQLParserDOCUMENT_P, PostgreSQLParserDOMAIN_P, PostgreSQLParserDOUBLE_P, PostgreSQLParserDROP, PostgreSQLParserEACH, PostgreSQLParserENABLE_P, PostgreSQLParserENCODING, PostgreSQLParserENCRYPTED, PostgreSQLParserENUM_P, PostgreSQLParserESCAPE, PostgreSQLParserEVENT, PostgreSQLParserEXCLUDE, PostgreSQLParserEXCLUDING, PostgreSQLParserEXCLUSIVE, PostgreSQLParserEXECUTE, PostgreSQLParserEXPLAIN, PostgreSQLParserEXTENSION, PostgreSQLParserEXTERNAL, PostgreSQLParserFAMILY, PostgreSQLParserFIRST_P, PostgreSQLParserFOLLOWING, PostgreSQLParserFORCE, PostgreSQLParserFORWARD, PostgreSQLParserFUNCTION, PostgreSQLParserFUNCTIONS, PostgreSQLParserGLOBAL, PostgreSQLParserGRANTED, PostgreSQLParserHANDLER, PostgreSQLParserHEADER_P, PostgreSQLParserHOLD, PostgreSQLParserHOUR_P, PostgreSQLParserIDENTITY_P, PostgreSQLParserIF_P, PostgreSQLParserIMMEDIATE, PostgreSQLParserIMMUTABLE, PostgreSQLParserIMPLICIT_P, PostgreSQLParserINCLUDING, PostgreSQLParserINCREMENT, PostgreSQLParserINDEX, PostgreSQLParserINDEXES, PostgreSQLParserINHERIT, PostgreSQLParserINHERITS, PostgreSQLParserINLINE_P, PostgreSQLParserINSENSITIVE, PostgreSQLParserINSERT, PostgreSQLParserINSTEAD, PostgreSQLParserINVOKER, PostgreSQLParserISOLATION, PostgreSQLParserKEY, PostgreSQLParserLABEL, PostgreSQLParserLANGUAGE, PostgreSQLParserLARGE_P, PostgreSQLParserLAST_P, PostgreSQLParserLEAKPROOF, PostgreSQLParserLEVEL, PostgreSQLParserLISTEN, PostgreSQLParserLOAD, PostgreSQLParserLOCAL, PostgreSQLParserLOCATION, PostgreSQLParserLOCK_P, PostgreSQLParserMAPPING, PostgreSQLParserMATCH, PostgreSQLParserMATERIALIZED, PostgreSQLParserMAXVALUE, PostgreSQLParserMINUTE_P, PostgreSQLParserMINVALUE, PostgreSQLParserMODE, PostgreSQLParserMONTH_P, PostgreSQLParserMOVE, PostgreSQLParserNAME_P, PostgreSQLParserNAMES, PostgreSQLParserNEXT, PostgreSQLParserNO, PostgreSQLParserNOTHING, PostgreSQLParserNOTIFY, PostgreSQLParserNOWAIT, PostgreSQLParserNULLS_P, PostgreSQLParserOBJECT_P, PostgreSQLParserOF, PostgreSQLParserOFF, PostgreSQLParserOIDS, PostgreSQLParserOPERATOR, PostgreSQLParserOPTION, PostgreSQLParserOPTIONS, PostgreSQLParserOWNED, PostgreSQLParserOWNER, PostgreSQLParserPARSER, PostgreSQLParserPARTIAL, PostgreSQLParserPARTITION, PostgreSQLParserPASSING, PostgreSQLParserPASSWORD, PostgreSQLParserPLANS, PostgreSQLParserPRECEDING, PostgreSQLParserPREPARE, PostgreSQLParserPREPARED, PostgreSQLParserPRESERVE, PostgreSQLParserPRIOR, PostgreSQLParserPRIVILEGES, PostgreSQLParserPROCEDURAL, PostgreSQLParserPROCEDURE, PostgreSQLParserPROGRAM, PostgreSQLParserQUOTE, PostgreSQLParserRANGE, PostgreSQLParserREAD, PostgreSQLParserREASSIGN, PostgreSQLParserRECHECK, PostgreSQLParserRECURSIVE, PostgreSQLParserREF, PostgreSQLParserREFRESH, PostgreSQLParserREINDEX, PostgreSQLParserRELATIVE_P, PostgreSQLParserRELEASE, PostgreSQLParserRENAME, PostgreSQLParserREPEATABLE, PostgreSQLParserREPLACE, PostgreSQLParserREPLICA, PostgreSQLParserRESET, PostgreSQLParserRESTART, PostgreSQLParserRESTRICT, PostgreSQLParserRETURNS, PostgreSQLParserREVOKE, PostgreSQLParserROLE, PostgreSQLParserROLLBACK, PostgreSQLParserROWS, PostgreSQLParserRULE, PostgreSQLParserSAVEPOINT, PostgreSQLParserSCHEMA, PostgreSQLParserSCROLL, PostgreSQLParserSEARCH, PostgreSQLParserSECOND_P, PostgreSQLParserSECURITY, PostgreSQLParserSEQUENCE, PostgreSQLParserSEQUENCES, PostgreSQLParserSERIALIZABLE, PostgreSQLParserSERVER, PostgreSQLParserSESSION, PostgreSQLParserSET, PostgreSQLParserSHARE, PostgreSQLParserSHOW, PostgreSQLParserSIMPLE, PostgreSQLParserSNAPSHOT, PostgreSQLParserSTABLE, PostgreSQLParserSTANDALONE_P, PostgreSQLParserSTART, PostgreSQLParserSTATEMENT, PostgreSQLParserSTATISTICS, PostgreSQLParserSTDIN, PostgreSQLParserSTDOUT, PostgreSQLParserSTORAGE, PostgreSQLParserSTRICT_P, PostgreSQLParserSTRIP_P, PostgreSQLParserSYSID, PostgreSQLParserSYSTEM_P, PostgreSQLParserTABLES, PostgreSQLParserTABLESPACE, PostgreSQLParserTEMP, PostgreSQLParserTEMPLATE, PostgreSQLParserTEMPORARY, PostgreSQLParserTEXT_P, PostgreSQLParserTRANSACTION, PostgreSQLParserTRIGGER, PostgreSQLParserTRUNCATE, PostgreSQLParserTRUSTED, PostgreSQLParserTYPE_P, PostgreSQLParserTYPES_P, PostgreSQLParserUNBOUNDED, PostgreSQLParserUNCOMMITTED, PostgreSQLParserUNENCRYPTED, PostgreSQLParserUNKNOWN, PostgreSQLParserUNLISTEN, PostgreSQLParserUNLOGGED, PostgreSQLParserUNTIL, PostgreSQLParserUPDATE, PostgreSQLParserVACUUM, PostgreSQLParserVALID, PostgreSQLParserVALIDATE, PostgreSQLParserVALIDATOR, PostgreSQLParserVARYING, PostgreSQLParserVERSION_P, PostgreSQLParserVIEW, PostgreSQLParserVOLATILE, PostgreSQLParserWHITESPACE_P, PostgreSQLParserWITHOUT, PostgreSQLParserWORK, PostgreSQLParserWRAPPER, PostgreSQLParserWRITE, PostgreSQLParserXML_P, PostgreSQLParserYEAR_P, PostgreSQLParserYES_P, PostgreSQLParserZONE, PostgreSQLParserBETWEEN, PostgreSQLParserBIGINT, PostgreSQLParserBIT, PostgreSQLParserBOOLEAN_P, PostgreSQLParserCHAR_P, PostgreSQLParserCHARACTER, PostgreSQLParserCOALESCE, PostgreSQLParserDEC, PostgreSQLParserDECIMAL_P, PostgreSQLParserEXISTS, PostgreSQLParserEXTRACT, PostgreSQLParserFLOAT_P, PostgreSQLParserGREATEST, PostgreSQLParserINOUT, PostgreSQLParserINT_P, PostgreSQLParserINTEGER, PostgreSQLParserINTERVAL, PostgreSQLParserLEAST, PostgreSQLParserNATIONAL, PostgreSQLParserNCHAR, PostgreSQLParserNONE, PostgreSQLParserNULLIF, PostgreSQLParserNUMERIC, PostgreSQLParserOVERLAY, PostgreSQLParserPOSITION, PostgreSQLParserPRECISION, PostgreSQLParserREAL, PostgreSQLParserROW, PostgreSQLParserSETOF, PostgreSQLParserSMALLINT, PostgreSQLParserSUBSTRING, PostgreSQLParserTIME, PostgreSQLParserTIMESTAMP, PostgreSQLParserTREAT, PostgreSQLParserTRIM, PostgreSQLParserVALUES, PostgreSQLParserVARCHAR, PostgreSQLParserXMLATTRIBUTES, PostgreSQLParserXMLCOMMENT, PostgreSQLParserXMLAGG, PostgreSQLParserXML_IS_WELL_FORMED, PostgreSQLParserXML_IS_WELL_FORMED_DOCUMENT, PostgreSQLParserXML_IS_WELL_FORMED_CONTENT, PostgreSQLParserXPATH, PostgreSQLParserXPATH_EXISTS, PostgreSQLParserXMLCONCAT, PostgreSQLParserXMLELEMENT, PostgreSQLParserXMLEXISTS, PostgreSQLParserXMLFOREST, PostgreSQLParserXMLPARSE, PostgreSQLParserXMLPI, PostgreSQLParserXMLROOT, PostgreSQLParserXMLSERIALIZE, PostgreSQLParserCALL, PostgreSQLParserCURRENT_P, PostgreSQLParserATTACH, PostgreSQLParserDETACH, PostgreSQLParserEXPRESSION, PostgreSQLParserGENERATED, PostgreSQLParserLOGGED, PostgreSQLParserSTORED, PostgreSQLParserINCLUDE, PostgreSQLParserROUTINE, PostgreSQLParserTRANSFORM, PostgreSQLParserIMPORT_P, PostgreSQLParserPOLICY, PostgreSQLParserMETHOD, PostgreSQLParserREFERENCING, PostgreSQLParserNEW, PostgreSQLParserOLD, PostgreSQLParserVALUE_P, PostgreSQLParserSUBSCRIPTION, PostgreSQLParserPUBLICATION, PostgreSQLParserOUT_P, PostgreSQLParserROUTINES, PostgreSQLParserSCHEMAS, PostgreSQLParserPROCEDURES, PostgreSQLParserINPUT_P, PostgreSQLParserSUPPORT, PostgreSQLParserPARALLEL, PostgreSQLParserSQL_P, PostgreSQLParserDEPENDS, PostgreSQLParserOVERRIDING, PostgreSQLParserCONFLICT, PostgreSQLParserSKIP_P, PostgreSQLParserLOCKED, PostgreSQLParserTIES, PostgreSQLParserROLLUP, PostgreSQLParserCUBE, PostgreSQLParserGROUPING, PostgreSQLParserSETS, PostgreSQLParserORDINALITY, PostgreSQLParserXMLTABLE, PostgreSQLParserCOLUMNS, PostgreSQLParserXMLNAMESPACES, PostgreSQLParserROWTYPE, PostgreSQLParserNORMALIZED, PostgreSQLParserWITHIN, PostgreSQLParserFILTER, PostgreSQLParserGROUPS, PostgreSQLParserOTHERS, PostgreSQLParserNFC, PostgreSQLParserNFD, PostgreSQLParserNFKC, PostgreSQLParserNFKD, PostgreSQLParserUESCAPE, PostgreSQLParserVIEWS, PostgreSQLParserNORMALIZE, PostgreSQLParserDUMP, PostgreSQLParserPRINT_STRICT_PARAMS, PostgreSQLParserVARIABLE_CONFLICT, PostgreSQLParserERROR, PostgreSQLParserUSE_VARIABLE, PostgreSQLParserUSE_COLUMN, PostgreSQLParserALIAS, PostgreSQLParserCONSTANT, PostgreSQLParserPERFORM, PostgreSQLParserGET, PostgreSQLParserDIAGNOSTICS, PostgreSQLParserSTACKED, PostgreSQLParserELSIF, PostgreSQLParserREVERSE, PostgreSQLParserSLICE, PostgreSQLParserEXIT, PostgreSQLParserRETURN, PostgreSQLParserQUERY, PostgreSQLParserRAISE, PostgreSQLParserSQLSTATE, PostgreSQLParserDEBUG, PostgreSQLParserLOG, PostgreSQLParserINFO, PostgreSQLParserNOTICE, PostgreSQLParserWARNING, PostgreSQLParserEXCEPTION, PostgreSQLParserASSERT, PostgreSQLParserOPEN, PostgreSQLParserABS, PostgreSQLParserCBRT, PostgreSQLParserCEIL, PostgreSQLParserCEILING, PostgreSQLParserDEGREES, PostgreSQLParserDIV, PostgreSQLParserEXP, PostgreSQLParserFACTORIAL, PostgreSQLParserFLOOR, PostgreSQLParserGCD, PostgreSQLParserLCM, PostgreSQLParserLN, PostgreSQLParserLOG10, PostgreSQLParserMIN_SCALE, PostgreSQLParserMOD, PostgreSQLParserPI, PostgreSQLParserPOWER, PostgreSQLParserRADIANS, PostgreSQLParserROUND, PostgreSQLParserSCALE, PostgreSQLParserSIGN, PostgreSQLParserSQRT, PostgreSQLParserTRIM_SCALE, PostgreSQLParserTRUNC, PostgreSQLParserWIDTH_BUCKET, PostgreSQLParserRANDOM, PostgreSQLParserSETSEED, PostgreSQLParserACOS, PostgreSQLParserACOSD, PostgreSQLParserASIN, PostgreSQLParserASIND, PostgreSQLParserATAN, PostgreSQLParserATAND, PostgreSQLParserATAN2, PostgreSQLParserATAN2D, PostgreSQLParserCOS, PostgreSQLParserCOSD, PostgreSQLParserCOT, PostgreSQLParserCOTD, PostgreSQLParserSIN, PostgreSQLParserSIND, PostgreSQLParserTAN, PostgreSQLParserTAND, PostgreSQLParserSINH, PostgreSQLParserCOSH, PostgreSQLParserTANH, PostgreSQLParserASINH, PostgreSQLParserACOSH, PostgreSQLParserATANH, PostgreSQLParserBIT_LENGTH, PostgreSQLParserCHAR_LENGTH, PostgreSQLParserCHARACTER_LENGTH, PostgreSQLParserLOWER, PostgreSQLParserOCTET_LENGTH, PostgreSQLParserUPPER, PostgreSQLParserASCII, PostgreSQLParserBTRIM, PostgreSQLParserCHR, PostgreSQLParserCONCAT, PostgreSQLParserCONCAT_WS, PostgreSQLParserFORMAT, PostgreSQLParserINITCAP, PostgreSQLParserLENGTH, PostgreSQLParserLPAD, PostgreSQLParserLTRIM, PostgreSQLParserMD5, PostgreSQLParserPARSE_IDENT, PostgreSQLParserPG_CLIENT_ENCODING, PostgreSQLParserQUOTE_IDENT, PostgreSQLParserQUOTE_LITERAL, PostgreSQLParserQUOTE_NULLABLE, PostgreSQLParserREGEXP_COUNT, PostgreSQLParserREGEXP_INSTR, PostgreSQLParserREGEXP_LIKE, PostgreSQLParserREGEXP_MATCH, PostgreSQLParserREGEXP_MATCHES, PostgreSQLParserREGEXP_REPLACE, PostgreSQLParserREGEXP_SPLIT_TO_ARRAY, PostgreSQLParserREGEXP_SPLIT_TO_TABLE, PostgreSQLParserREGEXP_SUBSTR, PostgreSQLParserREPEAT, PostgreSQLParserRPAD, PostgreSQLParserRTRIM, PostgreSQLParserSPLIT_PART, PostgreSQLParserSTARTS_WITH, PostgreSQLParserSTRING_TO_ARRAY, PostgreSQLParserSTRING_TO_TABLE, PostgreSQLParserSTRPOS, PostgreSQLParserSUBSTR, PostgreSQLParserTO_ASCII, PostgreSQLParserTO_HEX, PostgreSQLParserTRANSLATE, PostgreSQLParserUNISTR, PostgreSQLParserAGE, PostgreSQLParserCLOCK_TIMESTAMP, PostgreSQLParserDATE_BIN, PostgreSQLParserDATE_PART, PostgreSQLParserDATE_TRUNC, PostgreSQLParserISFINITE, PostgreSQLParserJUSTIFY_DAYS, PostgreSQLParserJUSTIFY_HOURS, PostgreSQLParserJUSTIFY_INTERVAL, PostgreSQLParserMAKE_DATE, PostgreSQLParserMAKE_INTERVAL, PostgreSQLParserMAKE_TIME, PostgreSQLParserMAKE_TIMESTAMP, PostgreSQLParserMAKE_TIMESTAMPTZ, PostgreSQLParserNOW, PostgreSQLParserSTATEMENT_TIMESTAMP, PostgreSQLParserTIMEOFDAY, PostgreSQLParserTRANSACTION_TIMESTAMP, PostgreSQLParserTO_TIMESTAMP, PostgreSQLParserTO_CHAR, PostgreSQLParserTO_DATE, PostgreSQLParserTO_NUMBER, PostgreSQLParserIdentifier, PostgreSQLParserQuotedIdentifier, PostgreSQLParserUnicodeQuotedIdentifier, PostgreSQLParserPLSQLVARIABLENAME, PostgreSQLParserPLSQLIDENTIFIER:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(8516)
			p.Tablefuncelementlist()
		}

	case PostgreSQLParserCLOSE_PAREN:
		p.EnterOuterAlt(localctx, 2)

	default:
		p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// ITablefuncelementlistContext is an interface to support dynamic dispatch.
type ITablefuncelementlistContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	AllTablefuncelement() []ITablefuncelementContext
	Tablefuncelement(i int) ITablefuncelementContext
	AllCOMMA() []antlr.TerminalNode
	COMMA(i int) antlr.TerminalNode

	// IsTablefuncelementlistContext differentiates from other interfaces.
	IsTablefuncelementlistContext()
}

type TablefuncelementlistContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyTablefuncelementlistContext() *TablefuncelementlistContext {
	var p = new(TablefuncelementlistContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_tablefuncelementlist
	return p
}

func InitEmptyTablefuncelementlistContext(p *TablefuncelementlistContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_tablefuncelementlist
}

func (*TablefuncelementlistContext) IsTablefuncelementlistContext() {}

func NewTablefuncelementlistContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TablefuncelementlistContext {
	var p = new(TablefuncelementlistContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_tablefuncelementlist

	return p
}

func (s *TablefuncelementlistContext) GetParser() antlr.Parser { return s.parser }

func (s *TablefuncelementlistContext) AllTablefuncelement() []ITablefuncelementContext {
	children := s.GetChildren()
	len := 0
	for _, ctx := range children {
		if _, ok := ctx.(ITablefuncelementContext); ok {
			len++
		}
	}

	tst := make([]ITablefuncelementContext, len)
	i := 0
	for _, ctx := range children {
		if t, ok := ctx.(ITablefuncelementContext); ok {
			tst[i] = t.(ITablefuncelementContext)
			i++
		}
	}

	return tst
}

func (s *TablefuncelementlistContext) Tablefuncelement(i int) ITablefuncelementContext {
	var t antlr.RuleContext
	j := 0
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ITablefuncelementContext); ok {
			if j == i {
				t = ctx.(antlr.RuleContext)
				break
			}
			j++
		}
	}

	if t == nil {
		return nil
	}

	return t.(ITablefuncelementContext)
}

func (s *TablefuncelementlistContext) AllCOMMA() []antlr.TerminalNode {
	return s.GetTokens(PostgreSQLParserCOMMA)
}

func (s *TablefuncelementlistContext) COMMA(i int) antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCOMMA, i)
}

func (s *TablefuncelementlistContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *TablefuncelementlistContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *TablefuncelementlistContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterTablefuncelementlist(s)
	}
}

func (s *TablefuncelementlistContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitTablefuncelementlist(s)
	}
}

func (s *TablefuncelementlistContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitTablefuncelementlist(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Tablefuncelementlist() (localctx ITablefuncelementlistContext) {
	localctx = NewTablefuncelementlistContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1100, PostgreSQLParserRULE_tablefuncelementlist)
	var _la int

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(8520)
		p.Tablefuncelement()
	}
	p.SetState(8525)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}
	_la = p.GetTokenStream().LA(1)

	for _la == PostgreSQLParserCOMMA {
		{
			p.SetState(8521)
			p.Match(PostgreSQLParserCOMMA)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(8522)
			p.Tablefuncelement()
		}

		p.SetState(8527)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}
		_la = p.GetTokenStream().LA(1)
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// ITablefuncelementContext is an interface to support dynamic dispatch.
type ITablefuncelementContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Colid() IColidContext
	Typename() ITypenameContext
	Opt_collate_clause() IOpt_collate_clauseContext

	// IsTablefuncelementContext differentiates from other interfaces.
	IsTablefuncelementContext()
}

type TablefuncelementContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyTablefuncelementContext() *TablefuncelementContext {
	var p = new(TablefuncelementContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_tablefuncelement
	return p
}

func InitEmptyTablefuncelementContext(p *TablefuncelementContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_tablefuncelement
}

func (*TablefuncelementContext) IsTablefuncelementContext() {}

func NewTablefuncelementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TablefuncelementContext {
	var p = new(TablefuncelementContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_tablefuncelement

	return p
}

func (s *TablefuncelementContext) GetParser() antlr.Parser { return s.parser }

func (s *TablefuncelementContext) Colid() IColidContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IColidContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IColidContext)
}

func (s *TablefuncelementContext) Typename() ITypenameContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ITypenameContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ITypenameContext)
}

func (s *TablefuncelementContext) Opt_collate_clause() IOpt_collate_clauseContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOpt_collate_clauseContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOpt_collate_clauseContext)
}

func (s *TablefuncelementContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *TablefuncelementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *TablefuncelementContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterTablefuncelement(s)
	}
}

func (s *TablefuncelementContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitTablefuncelement(s)
	}
}

func (s *TablefuncelementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitTablefuncelement(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Tablefuncelement() (localctx ITablefuncelementContext) {
	localctx = NewTablefuncelementContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1102, PostgreSQLParserRULE_tablefuncelement)
	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(8528)
		p.Colid()
	}
	{
		p.SetState(8529)
		p.Typename()
	}
	{
		p.SetState(8530)
		p.Opt_collate_clause()
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IXmltableContext is an interface to support dynamic dispatch.
type IXmltableContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	XMLTABLE() antlr.TerminalNode
	AllOPEN_PAREN() []antlr.TerminalNode
	OPEN_PAREN(i int) antlr.TerminalNode
	AllCLOSE_PAREN() []antlr.TerminalNode
	CLOSE_PAREN(i int) antlr.TerminalNode
	C_expr() IC_exprContext
	Xmlexists_argument() IXmlexists_argumentContext
	COLUMNS() antlr.TerminalNode
	Xmltable_column_list() IXmltable_column_listContext
	XMLNAMESPACES() antlr.TerminalNode
	Xml_namespace_list() IXml_namespace_listContext
	COMMA() antlr.TerminalNode

	// IsXmltableContext differentiates from other interfaces.
	IsXmltableContext()
}

type XmltableContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyXmltableContext() *XmltableContext {
	var p = new(XmltableContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_xmltable
	return p
}

func InitEmptyXmltableContext(p *XmltableContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_xmltable
}

func (*XmltableContext) IsXmltableContext() {}

func NewXmltableContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *XmltableContext {
	var p = new(XmltableContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_xmltable

	return p
}

func (s *XmltableContext) GetParser() antlr.Parser { return s.parser }

func (s *XmltableContext) XMLTABLE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserXMLTABLE, 0)
}

func (s *XmltableContext) AllOPEN_PAREN() []antlr.TerminalNode {
	return s.GetTokens(PostgreSQLParserOPEN_PAREN)
}

func (s *XmltableContext) OPEN_PAREN(i int) antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserOPEN_PAREN, i)
}

func (s *XmltableContext) AllCLOSE_PAREN() []antlr.TerminalNode {
	return s.GetTokens(PostgreSQLParserCLOSE_PAREN)
}

func (s *XmltableContext) CLOSE_PAREN(i int) antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCLOSE_PAREN, i)
}

func (s *XmltableContext) C_expr() IC_exprContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IC_exprContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IC_exprContext)
}

func (s *XmltableContext) Xmlexists_argument() IXmlexists_argumentContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IXmlexists_argumentContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IXmlexists_argumentContext)
}

func (s *XmltableContext) COLUMNS() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCOLUMNS, 0)
}

func (s *XmltableContext) Xmltable_column_list() IXmltable_column_listContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IXmltable_column_listContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IXmltable_column_listContext)
}

func (s *XmltableContext) XMLNAMESPACES() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserXMLNAMESPACES, 0)
}

func (s *XmltableContext) Xml_namespace_list() IXml_namespace_listContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IXml_namespace_listContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IXml_namespace_listContext)
}

func (s *XmltableContext) COMMA() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCOMMA, 0)
}

func (s *XmltableContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *XmltableContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *XmltableContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterXmltable(s)
	}
}

func (s *XmltableContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitXmltable(s)
	}
}

func (s *XmltableContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitXmltable(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Xmltable() (localctx IXmltableContext) {
	localctx = NewXmltableContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1104, PostgreSQLParserRULE_xmltable)
	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(8532)
		p.Match(PostgreSQLParserXMLTABLE)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(8533)
		p.Match(PostgreSQLParserOPEN_PAREN)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	p.SetState(8549)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 506, p.GetParserRuleContext()) {
	case 1:
		{
			p.SetState(8534)
			p.C_expr()
		}
		{
			p.SetState(8535)
			p.Xmlexists_argument()
		}
		{
			p.SetState(8536)
			p.Match(PostgreSQLParserCOLUMNS)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(8537)
			p.Xmltable_column_list()
		}

	case 2:
		{
			p.SetState(8539)
			p.Match(PostgreSQLParserXMLNAMESPACES)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(8540)
			p.Match(PostgreSQLParserOPEN_PAREN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(8541)
			p.Xml_namespace_list()
		}
		{
			p.SetState(8542)
			p.Match(PostgreSQLParserCLOSE_PAREN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(8543)
			p.Match(PostgreSQLParserCOMMA)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(8544)
			p.C_expr()
		}
		{
			p.SetState(8545)
			p.Xmlexists_argument()
		}
		{
			p.SetState(8546)
			p.Match(PostgreSQLParserCOLUMNS)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(8547)
			p.Xmltable_column_list()
		}

	case antlr.ATNInvalidAltNumber:
		goto errorExit
	}
	{
		p.SetState(8551)
		p.Match(PostgreSQLParserCLOSE_PAREN)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IXmltable_column_listContext is an interface to support dynamic dispatch.
type IXmltable_column_listContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	AllXmltable_column_el() []IXmltable_column_elContext
	Xmltable_column_el(i int) IXmltable_column_elContext
	AllCOMMA() []antlr.TerminalNode
	COMMA(i int) antlr.TerminalNode

	// IsXmltable_column_listContext differentiates from other interfaces.
	IsXmltable_column_listContext()
}

type Xmltable_column_listContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyXmltable_column_listContext() *Xmltable_column_listContext {
	var p = new(Xmltable_column_listContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_xmltable_column_list
	return p
}

func InitEmptyXmltable_column_listContext(p *Xmltable_column_listContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_xmltable_column_list
}

func (*Xmltable_column_listContext) IsXmltable_column_listContext() {}

func NewXmltable_column_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Xmltable_column_listContext {
	var p = new(Xmltable_column_listContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_xmltable_column_list

	return p
}

func (s *Xmltable_column_listContext) GetParser() antlr.Parser { return s.parser }

func (s *Xmltable_column_listContext) AllXmltable_column_el() []IXmltable_column_elContext {
	children := s.GetChildren()
	len := 0
	for _, ctx := range children {
		if _, ok := ctx.(IXmltable_column_elContext); ok {
			len++
		}
	}

	tst := make([]IXmltable_column_elContext, len)
	i := 0
	for _, ctx := range children {
		if t, ok := ctx.(IXmltable_column_elContext); ok {
			tst[i] = t.(IXmltable_column_elContext)
			i++
		}
	}

	return tst
}

func (s *Xmltable_column_listContext) Xmltable_column_el(i int) IXmltable_column_elContext {
	var t antlr.RuleContext
	j := 0
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IXmltable_column_elContext); ok {
			if j == i {
				t = ctx.(antlr.RuleContext)
				break
			}
			j++
		}
	}

	if t == nil {
		return nil
	}

	return t.(IXmltable_column_elContext)
}

func (s *Xmltable_column_listContext) AllCOMMA() []antlr.TerminalNode {
	return s.GetTokens(PostgreSQLParserCOMMA)
}

func (s *Xmltable_column_listContext) COMMA(i int) antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCOMMA, i)
}

func (s *Xmltable_column_listContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Xmltable_column_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Xmltable_column_listContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterXmltable_column_list(s)
	}
}

func (s *Xmltable_column_listContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitXmltable_column_list(s)
	}
}

func (s *Xmltable_column_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitXmltable_column_list(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Xmltable_column_list() (localctx IXmltable_column_listContext) {
	localctx = NewXmltable_column_listContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1106, PostgreSQLParserRULE_xmltable_column_list)
	var _la int

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(8553)
		p.Xmltable_column_el()
	}
	p.SetState(8558)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}
	_la = p.GetTokenStream().LA(1)

	for _la == PostgreSQLParserCOMMA {
		{
			p.SetState(8554)
			p.Match(PostgreSQLParserCOMMA)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(8555)
			p.Xmltable_column_el()
		}

		p.SetState(8560)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}
		_la = p.GetTokenStream().LA(1)
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IXmltable_column_elContext is an interface to support dynamic dispatch.
type IXmltable_column_elContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Colid() IColidContext
	Typename() ITypenameContext
	FOR() antlr.TerminalNode
	ORDINALITY() antlr.TerminalNode
	Xmltable_column_option_list() IXmltable_column_option_listContext

	// IsXmltable_column_elContext differentiates from other interfaces.
	IsXmltable_column_elContext()
}

type Xmltable_column_elContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyXmltable_column_elContext() *Xmltable_column_elContext {
	var p = new(Xmltable_column_elContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_xmltable_column_el
	return p
}

func InitEmptyXmltable_column_elContext(p *Xmltable_column_elContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_xmltable_column_el
}

func (*Xmltable_column_elContext) IsXmltable_column_elContext() {}

func NewXmltable_column_elContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Xmltable_column_elContext {
	var p = new(Xmltable_column_elContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_xmltable_column_el

	return p
}

func (s *Xmltable_column_elContext) GetParser() antlr.Parser { return s.parser }

func (s *Xmltable_column_elContext) Colid() IColidContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IColidContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IColidContext)
}

func (s *Xmltable_column_elContext) Typename() ITypenameContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ITypenameContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ITypenameContext)
}

func (s *Xmltable_column_elContext) FOR() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserFOR, 0)
}

func (s *Xmltable_column_elContext) ORDINALITY() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserORDINALITY, 0)
}

func (s *Xmltable_column_elContext) Xmltable_column_option_list() IXmltable_column_option_listContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IXmltable_column_option_listContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IXmltable_column_option_listContext)
}

func (s *Xmltable_column_elContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Xmltable_column_elContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Xmltable_column_elContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterXmltable_column_el(s)
	}
}

func (s *Xmltable_column_elContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitXmltable_column_el(s)
	}
}

func (s *Xmltable_column_elContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitXmltable_column_el(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Xmltable_column_el() (localctx IXmltable_column_elContext) {
	localctx = NewXmltable_column_elContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1108, PostgreSQLParserRULE_xmltable_column_el)
	var _la int

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(8561)
		p.Colid()
	}
	p.SetState(8568)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetTokenStream().LA(1) {
	case PostgreSQLParserAND, PostgreSQLParserARRAY, PostgreSQLParserCOLLATE, PostgreSQLParserCOLUMN, PostgreSQLParserCONSTRAINT, PostgreSQLParserDEFAULT, PostgreSQLParserDO, PostgreSQLParserFETCH, PostgreSQLParserTABLE, PostgreSQLParserAUTHORIZATION, PostgreSQLParserBINARY, PostgreSQLParserCOLLATION, PostgreSQLParserCONCURRENTLY, PostgreSQLParserCROSS, PostgreSQLParserCURRENT_SCHEMA, PostgreSQLParserFREEZE, PostgreSQLParserFULL, PostgreSQLParserILIKE, PostgreSQLParserINNER_P, PostgreSQLParserIS, PostgreSQLParserISNULL, PostgreSQLParserJOIN, PostgreSQLParserLEFT, PostgreSQLParserLIKE, PostgreSQLParserNATURAL, PostgreSQLParserNOTNULL, PostgreSQLParserOUTER_P, PostgreSQLParserOVER, PostgreSQLParserOVERLAPS, PostgreSQLParserRIGHT, PostgreSQLParserSIMILAR, PostgreSQLParserVERBOSE, PostgreSQLParserABORT_P, PostgreSQLParserABSOLUTE_P, PostgreSQLParserACCESS, PostgreSQLParserACTION, PostgreSQLParserADD_P, PostgreSQLParserADMIN, PostgreSQLParserAFTER, PostgreSQLParserAGGREGATE, PostgreSQLParserALSO, PostgreSQLParserALTER, PostgreSQLParserALWAYS, PostgreSQLParserASSERTION, PostgreSQLParserASSIGNMENT, PostgreSQLParserAT, PostgreSQLParserATTRIBUTE, PostgreSQLParserBACKWARD, PostgreSQLParserBEFORE, PostgreSQLParserBEGIN_P, PostgreSQLParserBY, PostgreSQLParserCACHE, PostgreSQLParserCALLED, PostgreSQLParserCASCADE, PostgreSQLParserCASCADED, PostgreSQLParserCATALOG, PostgreSQLParserCHAIN, PostgreSQLParserCHARACTERISTICS, PostgreSQLParserCHECKPOINT, PostgreSQLParserCLASS, PostgreSQLParserCLOSE, PostgreSQLParserCLUSTER, PostgreSQLParserCOMMENT, PostgreSQLParserCOMMENTS, PostgreSQLParserCOMMIT, PostgreSQLParserCOMMITTED, PostgreSQLParserCONFIGURATION, PostgreSQLParserCONNECTION, PostgreSQLParserCONSTRAINTS, PostgreSQLParserCONTENT_P, PostgreSQLParserCONTINUE_P, PostgreSQLParserCONVERSION_P, PostgreSQLParserCOPY, PostgreSQLParserCOST, PostgreSQLParserCSV, PostgreSQLParserCURSOR, PostgreSQLParserCYCLE, PostgreSQLParserDATA_P, PostgreSQLParserDATABASE, PostgreSQLParserDAY_P, PostgreSQLParserDEALLOCATE, PostgreSQLParserDECLARE, PostgreSQLParserDEFAULTS, PostgreSQLParserDEFERRED, PostgreSQLParserDEFINER, PostgreSQLParserDELETE_P, PostgreSQLParserDELIMITER, PostgreSQLParserDELIMITERS, PostgreSQLParserDICTIONARY, PostgreSQLParserDISABLE_P, PostgreSQLParserDISCARD, PostgreSQLParserDOCUMENT_P, PostgreSQLParserDOMAIN_P, PostgreSQLParserDOUBLE_P, PostgreSQLParserDROP, PostgreSQLParserEACH, PostgreSQLParserENABLE_P, PostgreSQLParserENCODING, PostgreSQLParserENCRYPTED, PostgreSQLParserENUM_P, PostgreSQLParserESCAPE, PostgreSQLParserEVENT, PostgreSQLParserEXCLUDE, PostgreSQLParserEXCLUDING, PostgreSQLParserEXCLUSIVE, PostgreSQLParserEXECUTE, PostgreSQLParserEXPLAIN, PostgreSQLParserEXTENSION, PostgreSQLParserEXTERNAL, PostgreSQLParserFAMILY, PostgreSQLParserFIRST_P, PostgreSQLParserFOLLOWING, PostgreSQLParserFORCE, PostgreSQLParserFORWARD, PostgreSQLParserFUNCTION, PostgreSQLParserFUNCTIONS, PostgreSQLParserGLOBAL, PostgreSQLParserGRANTED, PostgreSQLParserHANDLER, PostgreSQLParserHEADER_P, PostgreSQLParserHOLD, PostgreSQLParserHOUR_P, PostgreSQLParserIDENTITY_P, PostgreSQLParserIF_P, PostgreSQLParserIMMEDIATE, PostgreSQLParserIMMUTABLE, PostgreSQLParserIMPLICIT_P, PostgreSQLParserINCLUDING, PostgreSQLParserINCREMENT, PostgreSQLParserINDEX, PostgreSQLParserINDEXES, PostgreSQLParserINHERIT, PostgreSQLParserINHERITS, PostgreSQLParserINLINE_P, PostgreSQLParserINSENSITIVE, PostgreSQLParserINSERT, PostgreSQLParserINSTEAD, PostgreSQLParserINVOKER, PostgreSQLParserISOLATION, PostgreSQLParserKEY, PostgreSQLParserLABEL, PostgreSQLParserLANGUAGE, PostgreSQLParserLARGE_P, PostgreSQLParserLAST_P, PostgreSQLParserLEAKPROOF, PostgreSQLParserLEVEL, PostgreSQLParserLISTEN, PostgreSQLParserLOAD, PostgreSQLParserLOCAL, PostgreSQLParserLOCATION, PostgreSQLParserLOCK_P, PostgreSQLParserMAPPING, PostgreSQLParserMATCH, PostgreSQLParserMATERIALIZED, PostgreSQLParserMAXVALUE, PostgreSQLParserMINUTE_P, PostgreSQLParserMINVALUE, PostgreSQLParserMODE, PostgreSQLParserMONTH_P, PostgreSQLParserMOVE, PostgreSQLParserNAME_P, PostgreSQLParserNAMES, PostgreSQLParserNEXT, PostgreSQLParserNO, PostgreSQLParserNOTHING, PostgreSQLParserNOTIFY, PostgreSQLParserNOWAIT, PostgreSQLParserNULLS_P, PostgreSQLParserOBJECT_P, PostgreSQLParserOF, PostgreSQLParserOFF, PostgreSQLParserOIDS, PostgreSQLParserOPERATOR, PostgreSQLParserOPTION, PostgreSQLParserOPTIONS, PostgreSQLParserOWNED, PostgreSQLParserOWNER, PostgreSQLParserPARSER, PostgreSQLParserPARTIAL, PostgreSQLParserPARTITION, PostgreSQLParserPASSING, PostgreSQLParserPASSWORD, PostgreSQLParserPLANS, PostgreSQLParserPRECEDING, PostgreSQLParserPREPARE, PostgreSQLParserPREPARED, PostgreSQLParserPRESERVE, PostgreSQLParserPRIOR, PostgreSQLParserPRIVILEGES, PostgreSQLParserPROCEDURAL, PostgreSQLParserPROCEDURE, PostgreSQLParserPROGRAM, PostgreSQLParserQUOTE, PostgreSQLParserRANGE, PostgreSQLParserREAD, PostgreSQLParserREASSIGN, PostgreSQLParserRECHECK, PostgreSQLParserRECURSIVE, PostgreSQLParserREF, PostgreSQLParserREFRESH, PostgreSQLParserREINDEX, PostgreSQLParserRELATIVE_P, PostgreSQLParserRELEASE, PostgreSQLParserRENAME, PostgreSQLParserREPEATABLE, PostgreSQLParserREPLACE, PostgreSQLParserREPLICA, PostgreSQLParserRESET, PostgreSQLParserRESTART, PostgreSQLParserRESTRICT, PostgreSQLParserRETURNS, PostgreSQLParserREVOKE, PostgreSQLParserROLE, PostgreSQLParserROLLBACK, PostgreSQLParserROWS, PostgreSQLParserRULE, PostgreSQLParserSAVEPOINT, PostgreSQLParserSCHEMA, PostgreSQLParserSCROLL, PostgreSQLParserSEARCH, PostgreSQLParserSECOND_P, PostgreSQLParserSECURITY, PostgreSQLParserSEQUENCE, PostgreSQLParserSEQUENCES, PostgreSQLParserSERIALIZABLE, PostgreSQLParserSERVER, PostgreSQLParserSESSION, PostgreSQLParserSET, PostgreSQLParserSHARE, PostgreSQLParserSHOW, PostgreSQLParserSIMPLE, PostgreSQLParserSNAPSHOT, PostgreSQLParserSTABLE, PostgreSQLParserSTANDALONE_P, PostgreSQLParserSTART, PostgreSQLParserSTATEMENT, PostgreSQLParserSTATISTICS, PostgreSQLParserSTDIN, PostgreSQLParserSTDOUT, PostgreSQLParserSTORAGE, PostgreSQLParserSTRICT_P, PostgreSQLParserSTRIP_P, PostgreSQLParserSYSID, PostgreSQLParserSYSTEM_P, PostgreSQLParserTABLES, PostgreSQLParserTABLESPACE, PostgreSQLParserTEMP, PostgreSQLParserTEMPLATE, PostgreSQLParserTEMPORARY, PostgreSQLParserTEXT_P, PostgreSQLParserTRANSACTION, PostgreSQLParserTRIGGER, PostgreSQLParserTRUNCATE, PostgreSQLParserTRUSTED, PostgreSQLParserTYPE_P, PostgreSQLParserTYPES_P, PostgreSQLParserUNBOUNDED, PostgreSQLParserUNCOMMITTED, PostgreSQLParserUNENCRYPTED, PostgreSQLParserUNKNOWN, PostgreSQLParserUNLISTEN, PostgreSQLParserUNLOGGED, PostgreSQLParserUNTIL, PostgreSQLParserUPDATE, PostgreSQLParserVACUUM, PostgreSQLParserVALID, PostgreSQLParserVALIDATE, PostgreSQLParserVALIDATOR, PostgreSQLParserVARYING, PostgreSQLParserVERSION_P, PostgreSQLParserVIEW, PostgreSQLParserVOLATILE, PostgreSQLParserWHITESPACE_P, PostgreSQLParserWITHOUT, PostgreSQLParserWORK, PostgreSQLParserWRAPPER, PostgreSQLParserWRITE, PostgreSQLParserXML_P, PostgreSQLParserYEAR_P, PostgreSQLParserYES_P, PostgreSQLParserZONE, PostgreSQLParserBETWEEN, PostgreSQLParserBIGINT, PostgreSQLParserBIT, PostgreSQLParserBOOLEAN_P, PostgreSQLParserCHAR_P, PostgreSQLParserCHARACTER, PostgreSQLParserCOALESCE, PostgreSQLParserDEC, PostgreSQLParserDECIMAL_P, PostgreSQLParserEXISTS, PostgreSQLParserEXTRACT, PostgreSQLParserFLOAT_P, PostgreSQLParserGREATEST, PostgreSQLParserINOUT, PostgreSQLParserINT_P, PostgreSQLParserINTEGER, PostgreSQLParserINTERVAL, PostgreSQLParserLEAST, PostgreSQLParserNATIONAL, PostgreSQLParserNCHAR, PostgreSQLParserNONE, PostgreSQLParserNULLIF, PostgreSQLParserNUMERIC, PostgreSQLParserOVERLAY, PostgreSQLParserPOSITION, PostgreSQLParserPRECISION, PostgreSQLParserREAL, PostgreSQLParserROW, PostgreSQLParserSETOF, PostgreSQLParserSMALLINT, PostgreSQLParserSUBSTRING, PostgreSQLParserTIME, PostgreSQLParserTIMESTAMP, PostgreSQLParserTREAT, PostgreSQLParserTRIM, PostgreSQLParserVALUES, PostgreSQLParserVARCHAR, PostgreSQLParserXMLATTRIBUTES, PostgreSQLParserXMLCOMMENT, PostgreSQLParserXMLAGG, PostgreSQLParserXML_IS_WELL_FORMED, PostgreSQLParserXML_IS_WELL_FORMED_DOCUMENT, PostgreSQLParserXML_IS_WELL_FORMED_CONTENT, PostgreSQLParserXPATH, PostgreSQLParserXPATH_EXISTS, PostgreSQLParserXMLCONCAT, PostgreSQLParserXMLELEMENT, PostgreSQLParserXMLEXISTS, PostgreSQLParserXMLFOREST, PostgreSQLParserXMLPARSE, PostgreSQLParserXMLPI, PostgreSQLParserXMLROOT, PostgreSQLParserXMLSERIALIZE, PostgreSQLParserCALL, PostgreSQLParserCURRENT_P, PostgreSQLParserATTACH, PostgreSQLParserDETACH, PostgreSQLParserEXPRESSION, PostgreSQLParserGENERATED, PostgreSQLParserLOGGED, PostgreSQLParserSTORED, PostgreSQLParserINCLUDE, PostgreSQLParserROUTINE, PostgreSQLParserTRANSFORM, PostgreSQLParserIMPORT_P, PostgreSQLParserPOLICY, PostgreSQLParserMETHOD, PostgreSQLParserREFERENCING, PostgreSQLParserNEW, PostgreSQLParserOLD, PostgreSQLParserVALUE_P, PostgreSQLParserSUBSCRIPTION, PostgreSQLParserPUBLICATION, PostgreSQLParserOUT_P, PostgreSQLParserROUTINES, PostgreSQLParserSCHEMAS, PostgreSQLParserPROCEDURES, PostgreSQLParserINPUT_P, PostgreSQLParserSUPPORT, PostgreSQLParserPARALLEL, PostgreSQLParserSQL_P, PostgreSQLParserDEPENDS, PostgreSQLParserOVERRIDING, PostgreSQLParserCONFLICT, PostgreSQLParserSKIP_P, PostgreSQLParserLOCKED, PostgreSQLParserTIES, PostgreSQLParserROLLUP, PostgreSQLParserCUBE, PostgreSQLParserGROUPING, PostgreSQLParserSETS, PostgreSQLParserTABLESAMPLE, PostgreSQLParserORDINALITY, PostgreSQLParserXMLTABLE, PostgreSQLParserCOLUMNS, PostgreSQLParserXMLNAMESPACES, PostgreSQLParserROWTYPE, PostgreSQLParserNORMALIZED, PostgreSQLParserWITHIN, PostgreSQLParserFILTER, PostgreSQLParserGROUPS, PostgreSQLParserOTHERS, PostgreSQLParserNFC, PostgreSQLParserNFD, PostgreSQLParserNFKC, PostgreSQLParserNFKD, PostgreSQLParserUESCAPE, PostgreSQLParserVIEWS, PostgreSQLParserNORMALIZE, PostgreSQLParserDUMP, PostgreSQLParserPRINT_STRICT_PARAMS, PostgreSQLParserVARIABLE_CONFLICT, PostgreSQLParserERROR, PostgreSQLParserUSE_VARIABLE, PostgreSQLParserUSE_COLUMN, PostgreSQLParserALIAS, PostgreSQLParserCONSTANT, PostgreSQLParserPERFORM, PostgreSQLParserGET, PostgreSQLParserDIAGNOSTICS, PostgreSQLParserSTACKED, PostgreSQLParserELSIF, PostgreSQLParserREVERSE, PostgreSQLParserSLICE, PostgreSQLParserEXIT, PostgreSQLParserRETURN, PostgreSQLParserQUERY, PostgreSQLParserRAISE, PostgreSQLParserSQLSTATE, PostgreSQLParserDEBUG, PostgreSQLParserLOG, PostgreSQLParserINFO, PostgreSQLParserNOTICE, PostgreSQLParserWARNING, PostgreSQLParserEXCEPTION, PostgreSQLParserASSERT, PostgreSQLParserOPEN, PostgreSQLParserABS, PostgreSQLParserCBRT, PostgreSQLParserCEIL, PostgreSQLParserCEILING, PostgreSQLParserDEGREES, PostgreSQLParserDIV, PostgreSQLParserEXP, PostgreSQLParserFACTORIAL, PostgreSQLParserFLOOR, PostgreSQLParserGCD, PostgreSQLParserLCM, PostgreSQLParserLN, PostgreSQLParserLOG10, PostgreSQLParserMIN_SCALE, PostgreSQLParserMOD, PostgreSQLParserPI, PostgreSQLParserPOWER, PostgreSQLParserRADIANS, PostgreSQLParserROUND, PostgreSQLParserSCALE, PostgreSQLParserSIGN, PostgreSQLParserSQRT, PostgreSQLParserTRIM_SCALE, PostgreSQLParserTRUNC, PostgreSQLParserWIDTH_BUCKET, PostgreSQLParserRANDOM, PostgreSQLParserSETSEED, PostgreSQLParserACOS, PostgreSQLParserACOSD, PostgreSQLParserASIN, PostgreSQLParserASIND, PostgreSQLParserATAN, PostgreSQLParserATAND, PostgreSQLParserATAN2, PostgreSQLParserATAN2D, PostgreSQLParserCOS, PostgreSQLParserCOSD, PostgreSQLParserCOT, PostgreSQLParserCOTD, PostgreSQLParserSIN, PostgreSQLParserSIND, PostgreSQLParserTAN, PostgreSQLParserTAND, PostgreSQLParserSINH, PostgreSQLParserCOSH, PostgreSQLParserTANH, PostgreSQLParserASINH, PostgreSQLParserACOSH, PostgreSQLParserATANH, PostgreSQLParserBIT_LENGTH, PostgreSQLParserCHAR_LENGTH, PostgreSQLParserCHARACTER_LENGTH, PostgreSQLParserLOWER, PostgreSQLParserOCTET_LENGTH, PostgreSQLParserUPPER, PostgreSQLParserASCII, PostgreSQLParserBTRIM, PostgreSQLParserCHR, PostgreSQLParserCONCAT, PostgreSQLParserCONCAT_WS, PostgreSQLParserFORMAT, PostgreSQLParserINITCAP, PostgreSQLParserLENGTH, PostgreSQLParserLPAD, PostgreSQLParserLTRIM, PostgreSQLParserMD5, PostgreSQLParserPARSE_IDENT, PostgreSQLParserPG_CLIENT_ENCODING, PostgreSQLParserQUOTE_IDENT, PostgreSQLParserQUOTE_LITERAL, PostgreSQLParserQUOTE_NULLABLE, PostgreSQLParserREGEXP_COUNT, PostgreSQLParserREGEXP_INSTR, PostgreSQLParserREGEXP_LIKE, PostgreSQLParserREGEXP_MATCH, PostgreSQLParserREGEXP_MATCHES, PostgreSQLParserREGEXP_REPLACE, PostgreSQLParserREGEXP_SPLIT_TO_ARRAY, PostgreSQLParserREGEXP_SPLIT_TO_TABLE, PostgreSQLParserREGEXP_SUBSTR, PostgreSQLParserREPEAT, PostgreSQLParserRPAD, PostgreSQLParserRTRIM, PostgreSQLParserSPLIT_PART, PostgreSQLParserSTARTS_WITH, PostgreSQLParserSTRING_TO_ARRAY, PostgreSQLParserSTRING_TO_TABLE, PostgreSQLParserSTRPOS, PostgreSQLParserSUBSTR, PostgreSQLParserTO_ASCII, PostgreSQLParserTO_HEX, PostgreSQLParserTRANSLATE, PostgreSQLParserUNISTR, PostgreSQLParserAGE, PostgreSQLParserCLOCK_TIMESTAMP, PostgreSQLParserDATE_BIN, PostgreSQLParserDATE_PART, PostgreSQLParserDATE_TRUNC, PostgreSQLParserISFINITE, PostgreSQLParserJUSTIFY_DAYS, PostgreSQLParserJUSTIFY_HOURS, PostgreSQLParserJUSTIFY_INTERVAL, PostgreSQLParserMAKE_DATE, PostgreSQLParserMAKE_INTERVAL, PostgreSQLParserMAKE_TIME, PostgreSQLParserMAKE_TIMESTAMP, PostgreSQLParserMAKE_TIMESTAMPTZ, PostgreSQLParserNOW, PostgreSQLParserSTATEMENT_TIMESTAMP, PostgreSQLParserTIMEOFDAY, PostgreSQLParserTRANSACTION_TIMESTAMP, PostgreSQLParserTO_TIMESTAMP, PostgreSQLParserTO_CHAR, PostgreSQLParserTO_DATE, PostgreSQLParserTO_NUMBER, PostgreSQLParserIdentifier, PostgreSQLParserQuotedIdentifier, PostgreSQLParserUnicodeQuotedIdentifier, PostgreSQLParserPLSQLVARIABLENAME, PostgreSQLParserPLSQLIDENTIFIER:
		{
			p.SetState(8562)
			p.Typename()
		}
		p.SetState(8564)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}
		_la = p.GetTokenStream().LA(1)

		if ((int64((_la-33)) & ^0x3f) == 0 && ((int64(1)<<(_la-33))&576513529147825157) != 0) || ((int64((_la-116)) & ^0x3f) == 0 && ((int64(1)<<(_la-116))&74346914954363009) != 0) || ((int64((_la-207)) & ^0x3f) == 0 && ((int64(1)<<(_la-207))&56295003965620233) != 0) || ((int64((_la-272)) & ^0x3f) == 0 && ((int64(1)<<(_la-272))&18068292027564033) != 0) || _la == PostgreSQLParserTYPE_P || ((int64((_la-433)) & ^0x3f) == 0 && ((int64(1)<<(_la-433))&-144097595889811453) != 0) || ((int64((_la-497)) & ^0x3f) == 0 && ((int64(1)<<(_la-497))&12516927) != 0) || ((int64((_la-636)) & ^0x3f) == 0 && ((int64(1)<<(_la-636))&100663331) != 0) {
			{
				p.SetState(8563)
				p.Xmltable_column_option_list()
			}

		}

	case PostgreSQLParserFOR:
		{
			p.SetState(8566)
			p.Match(PostgreSQLParserFOR)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(8567)
			p.Match(PostgreSQLParserORDINALITY)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	default:
		p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IXmltable_column_option_listContext is an interface to support dynamic dispatch.
type IXmltable_column_option_listContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	AllXmltable_column_option_el() []IXmltable_column_option_elContext
	Xmltable_column_option_el(i int) IXmltable_column_option_elContext

	// IsXmltable_column_option_listContext differentiates from other interfaces.
	IsXmltable_column_option_listContext()
}

type Xmltable_column_option_listContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyXmltable_column_option_listContext() *Xmltable_column_option_listContext {
	var p = new(Xmltable_column_option_listContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_xmltable_column_option_list
	return p
}

func InitEmptyXmltable_column_option_listContext(p *Xmltable_column_option_listContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_xmltable_column_option_list
}

func (*Xmltable_column_option_listContext) IsXmltable_column_option_listContext() {}

func NewXmltable_column_option_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Xmltable_column_option_listContext {
	var p = new(Xmltable_column_option_listContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_xmltable_column_option_list

	return p
}

func (s *Xmltable_column_option_listContext) GetParser() antlr.Parser { return s.parser }

func (s *Xmltable_column_option_listContext) AllXmltable_column_option_el() []IXmltable_column_option_elContext {
	children := s.GetChildren()
	len := 0
	for _, ctx := range children {
		if _, ok := ctx.(IXmltable_column_option_elContext); ok {
			len++
		}
	}

	tst := make([]IXmltable_column_option_elContext, len)
	i := 0
	for _, ctx := range children {
		if t, ok := ctx.(IXmltable_column_option_elContext); ok {
			tst[i] = t.(IXmltable_column_option_elContext)
			i++
		}
	}

	return tst
}

func (s *Xmltable_column_option_listContext) Xmltable_column_option_el(i int) IXmltable_column_option_elContext {
	var t antlr.RuleContext
	j := 0
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IXmltable_column_option_elContext); ok {
			if j == i {
				t = ctx.(antlr.RuleContext)
				break
			}
			j++
		}
	}

	if t == nil {
		return nil
	}

	return t.(IXmltable_column_option_elContext)
}

func (s *Xmltable_column_option_listContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Xmltable_column_option_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Xmltable_column_option_listContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterXmltable_column_option_list(s)
	}
}

func (s *Xmltable_column_option_listContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitXmltable_column_option_list(s)
	}
}

func (s *Xmltable_column_option_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitXmltable_column_option_list(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Xmltable_column_option_list() (localctx IXmltable_column_option_listContext) {
	localctx = NewXmltable_column_option_listContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1110, PostgreSQLParserRULE_xmltable_column_option_list)
	var _la int

	p.EnterOuterAlt(localctx, 1)
	p.SetState(8571)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}
	_la = p.GetTokenStream().LA(1)

	for ok := true; ok; ok = ((int64((_la-33)) & ^0x3f) == 0 && ((int64(1)<<(_la-33))&576513529147825157) != 0) || ((int64((_la-116)) & ^0x3f) == 0 && ((int64(1)<<(_la-116))&74346914954363009) != 0) || ((int64((_la-207)) & ^0x3f) == 0 && ((int64(1)<<(_la-207))&56295003965620233) != 0) || ((int64((_la-272)) & ^0x3f) == 0 && ((int64(1)<<(_la-272))&18068292027564033) != 0) || _la == PostgreSQLParserTYPE_P || ((int64((_la-433)) & ^0x3f) == 0 && ((int64(1)<<(_la-433))&-144097595889811453) != 0) || ((int64((_la-497)) & ^0x3f) == 0 && ((int64(1)<<(_la-497))&12516927) != 0) || ((int64((_la-636)) & ^0x3f) == 0 && ((int64(1)<<(_la-636))&100663331) != 0) {
		{
			p.SetState(8570)
			p.Xmltable_column_option_el()
		}

		p.SetState(8573)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}
		_la = p.GetTokenStream().LA(1)
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IXmltable_column_option_elContext is an interface to support dynamic dispatch.
type IXmltable_column_option_elContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	DEFAULT() antlr.TerminalNode
	A_expr() IA_exprContext
	Identifier() IIdentifierContext
	NOT() antlr.TerminalNode
	NULL_P() antlr.TerminalNode

	// IsXmltable_column_option_elContext differentiates from other interfaces.
	IsXmltable_column_option_elContext()
}

type Xmltable_column_option_elContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyXmltable_column_option_elContext() *Xmltable_column_option_elContext {
	var p = new(Xmltable_column_option_elContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_xmltable_column_option_el
	return p
}

func InitEmptyXmltable_column_option_elContext(p *Xmltable_column_option_elContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_xmltable_column_option_el
}

func (*Xmltable_column_option_elContext) IsXmltable_column_option_elContext() {}

func NewXmltable_column_option_elContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Xmltable_column_option_elContext {
	var p = new(Xmltable_column_option_elContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_xmltable_column_option_el

	return p
}

func (s *Xmltable_column_option_elContext) GetParser() antlr.Parser { return s.parser }

func (s *Xmltable_column_option_elContext) DEFAULT() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserDEFAULT, 0)
}

func (s *Xmltable_column_option_elContext) A_expr() IA_exprContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IA_exprContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IA_exprContext)
}

func (s *Xmltable_column_option_elContext) Identifier() IIdentifierContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IIdentifierContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IIdentifierContext)
}

func (s *Xmltable_column_option_elContext) NOT() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserNOT, 0)
}

func (s *Xmltable_column_option_elContext) NULL_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserNULL_P, 0)
}

func (s *Xmltable_column_option_elContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Xmltable_column_option_elContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Xmltable_column_option_elContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterXmltable_column_option_el(s)
	}
}

func (s *Xmltable_column_option_elContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitXmltable_column_option_el(s)
	}
}

func (s *Xmltable_column_option_elContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitXmltable_column_option_el(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Xmltable_column_option_el() (localctx IXmltable_column_option_elContext) {
	localctx = NewXmltable_column_option_elContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1112, PostgreSQLParserRULE_xmltable_column_option_el)
	p.SetState(8583)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 511, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(8575)
			p.Match(PostgreSQLParserDEFAULT)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(8576)
			p.A_expr()
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(8577)
			p.Identifier()
		}
		{
			p.SetState(8578)
			p.A_expr()
		}

	case 3:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(8580)
			p.Match(PostgreSQLParserNOT)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(8581)
			p.Match(PostgreSQLParserNULL_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 4:
		p.EnterOuterAlt(localctx, 4)
		{
			p.SetState(8582)
			p.Match(PostgreSQLParserNULL_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case antlr.ATNInvalidAltNumber:
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IXml_namespace_listContext is an interface to support dynamic dispatch.
type IXml_namespace_listContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	AllXml_namespace_el() []IXml_namespace_elContext
	Xml_namespace_el(i int) IXml_namespace_elContext
	AllCOMMA() []antlr.TerminalNode
	COMMA(i int) antlr.TerminalNode

	// IsXml_namespace_listContext differentiates from other interfaces.
	IsXml_namespace_listContext()
}

type Xml_namespace_listContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyXml_namespace_listContext() *Xml_namespace_listContext {
	var p = new(Xml_namespace_listContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_xml_namespace_list
	return p
}

func InitEmptyXml_namespace_listContext(p *Xml_namespace_listContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_xml_namespace_list
}

func (*Xml_namespace_listContext) IsXml_namespace_listContext() {}

func NewXml_namespace_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Xml_namespace_listContext {
	var p = new(Xml_namespace_listContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_xml_namespace_list

	return p
}

func (s *Xml_namespace_listContext) GetParser() antlr.Parser { return s.parser }

func (s *Xml_namespace_listContext) AllXml_namespace_el() []IXml_namespace_elContext {
	children := s.GetChildren()
	len := 0
	for _, ctx := range children {
		if _, ok := ctx.(IXml_namespace_elContext); ok {
			len++
		}
	}

	tst := make([]IXml_namespace_elContext, len)
	i := 0
	for _, ctx := range children {
		if t, ok := ctx.(IXml_namespace_elContext); ok {
			tst[i] = t.(IXml_namespace_elContext)
			i++
		}
	}

	return tst
}

func (s *Xml_namespace_listContext) Xml_namespace_el(i int) IXml_namespace_elContext {
	var t antlr.RuleContext
	j := 0
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IXml_namespace_elContext); ok {
			if j == i {
				t = ctx.(antlr.RuleContext)
				break
			}
			j++
		}
	}

	if t == nil {
		return nil
	}

	return t.(IXml_namespace_elContext)
}

func (s *Xml_namespace_listContext) AllCOMMA() []antlr.TerminalNode {
	return s.GetTokens(PostgreSQLParserCOMMA)
}

func (s *Xml_namespace_listContext) COMMA(i int) antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCOMMA, i)
}

func (s *Xml_namespace_listContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Xml_namespace_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Xml_namespace_listContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterXml_namespace_list(s)
	}
}

func (s *Xml_namespace_listContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitXml_namespace_list(s)
	}
}

func (s *Xml_namespace_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitXml_namespace_list(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Xml_namespace_list() (localctx IXml_namespace_listContext) {
	localctx = NewXml_namespace_listContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1114, PostgreSQLParserRULE_xml_namespace_list)
	var _la int

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(8585)
		p.Xml_namespace_el()
	}
	p.SetState(8590)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}
	_la = p.GetTokenStream().LA(1)

	for _la == PostgreSQLParserCOMMA {
		{
			p.SetState(8586)
			p.Match(PostgreSQLParserCOMMA)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(8587)
			p.Xml_namespace_el()
		}

		p.SetState(8592)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}
		_la = p.GetTokenStream().LA(1)
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IXml_namespace_elContext is an interface to support dynamic dispatch.
type IXml_namespace_elContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	B_expr() IB_exprContext
	AS() antlr.TerminalNode
	Collabel() ICollabelContext
	DEFAULT() antlr.TerminalNode

	// IsXml_namespace_elContext differentiates from other interfaces.
	IsXml_namespace_elContext()
}

type Xml_namespace_elContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyXml_namespace_elContext() *Xml_namespace_elContext {
	var p = new(Xml_namespace_elContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_xml_namespace_el
	return p
}

func InitEmptyXml_namespace_elContext(p *Xml_namespace_elContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_xml_namespace_el
}

func (*Xml_namespace_elContext) IsXml_namespace_elContext() {}

func NewXml_namespace_elContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Xml_namespace_elContext {
	var p = new(Xml_namespace_elContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_xml_namespace_el

	return p
}

func (s *Xml_namespace_elContext) GetParser() antlr.Parser { return s.parser }

func (s *Xml_namespace_elContext) B_expr() IB_exprContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IB_exprContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IB_exprContext)
}

func (s *Xml_namespace_elContext) AS() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserAS, 0)
}

func (s *Xml_namespace_elContext) Collabel() ICollabelContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ICollabelContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ICollabelContext)
}

func (s *Xml_namespace_elContext) DEFAULT() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserDEFAULT, 0)
}

func (s *Xml_namespace_elContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Xml_namespace_elContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Xml_namespace_elContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterXml_namespace_el(s)
	}
}

func (s *Xml_namespace_elContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitXml_namespace_el(s)
	}
}

func (s *Xml_namespace_elContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitXml_namespace_el(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Xml_namespace_el() (localctx IXml_namespace_elContext) {
	localctx = NewXml_namespace_elContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1116, PostgreSQLParserRULE_xml_namespace_el)
	p.SetState(8599)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 513, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(8593)
			p.b_expr(0)
		}
		{
			p.SetState(8594)
			p.Match(PostgreSQLParserAS)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(8595)
			p.Collabel()
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(8597)
			p.Match(PostgreSQLParserDEFAULT)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(8598)
			p.b_expr(0)
		}

	case antlr.ATNInvalidAltNumber:
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// ITypenameContext is an interface to support dynamic dispatch.
type ITypenameContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Simpletypename() ISimpletypenameContext
	Opt_array_bounds() IOpt_array_boundsContext
	ARRAY() antlr.TerminalNode
	SETOF() antlr.TerminalNode
	OPEN_BRACKET() antlr.TerminalNode
	Iconst() IIconstContext
	CLOSE_BRACKET() antlr.TerminalNode
	Qualified_name() IQualified_nameContext
	PERCENT() antlr.TerminalNode
	ROWTYPE() antlr.TerminalNode
	TYPE_P() antlr.TerminalNode

	// IsTypenameContext differentiates from other interfaces.
	IsTypenameContext()
}

type TypenameContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyTypenameContext() *TypenameContext {
	var p = new(TypenameContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_typename
	return p
}

func InitEmptyTypenameContext(p *TypenameContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_typename
}

func (*TypenameContext) IsTypenameContext() {}

func NewTypenameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TypenameContext {
	var p = new(TypenameContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_typename

	return p
}

func (s *TypenameContext) GetParser() antlr.Parser { return s.parser }

func (s *TypenameContext) Simpletypename() ISimpletypenameContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ISimpletypenameContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ISimpletypenameContext)
}

func (s *TypenameContext) Opt_array_bounds() IOpt_array_boundsContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOpt_array_boundsContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOpt_array_boundsContext)
}

func (s *TypenameContext) ARRAY() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserARRAY, 0)
}

func (s *TypenameContext) SETOF() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserSETOF, 0)
}

func (s *TypenameContext) OPEN_BRACKET() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserOPEN_BRACKET, 0)
}

func (s *TypenameContext) Iconst() IIconstContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IIconstContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IIconstContext)
}

func (s *TypenameContext) CLOSE_BRACKET() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCLOSE_BRACKET, 0)
}

func (s *TypenameContext) Qualified_name() IQualified_nameContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IQualified_nameContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IQualified_nameContext)
}

func (s *TypenameContext) PERCENT() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserPERCENT, 0)
}

func (s *TypenameContext) ROWTYPE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserROWTYPE, 0)
}

func (s *TypenameContext) TYPE_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserTYPE_P, 0)
}

func (s *TypenameContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *TypenameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *TypenameContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterTypename(s)
	}
}

func (s *TypenameContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitTypename(s)
	}
}

func (s *TypenameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitTypename(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Typename() (localctx ITypenameContext) {
	localctx = NewTypenameContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1118, PostgreSQLParserRULE_typename)
	var _la int

	p.SetState(8619)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 517, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		p.SetState(8602)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}
		_la = p.GetTokenStream().LA(1)

		if _la == PostgreSQLParserSETOF {
			{
				p.SetState(8601)
				p.Match(PostgreSQLParserSETOF)
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}

		}
		{
			p.SetState(8604)
			p.Simpletypename()
		}
		p.SetState(8613)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}

		switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 516, p.GetParserRuleContext()) {
		case 1:
			{
				p.SetState(8605)
				p.Opt_array_bounds()
			}

		case 2:
			{
				p.SetState(8606)
				p.Match(PostgreSQLParserARRAY)
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}
			p.SetState(8611)
			p.GetErrorHandler().Sync(p)

			if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 515, p.GetParserRuleContext()) == 1 {
				{
					p.SetState(8607)
					p.Match(PostgreSQLParserOPEN_BRACKET)
					if p.HasError() {
						// Recognition error - abort rule
						goto errorExit
					}
				}
				{
					p.SetState(8608)
					p.Iconst()
				}
				{
					p.SetState(8609)
					p.Match(PostgreSQLParserCLOSE_BRACKET)
					if p.HasError() {
						// Recognition error - abort rule
						goto errorExit
					}
				}

			} else if p.HasError() { // JIM
				goto errorExit
			}

		case antlr.ATNInvalidAltNumber:
			goto errorExit
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(8615)
			p.Qualified_name()
		}
		{
			p.SetState(8616)
			p.Match(PostgreSQLParserPERCENT)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(8617)
			_la = p.GetTokenStream().LA(1)

			if !(_la == PostgreSQLParserTYPE_P || _la == PostgreSQLParserROWTYPE) {
				p.GetErrorHandler().RecoverInline(p)
			} else {
				p.GetErrorHandler().ReportMatch(p)
				p.Consume()
			}
		}

	case antlr.ATNInvalidAltNumber:
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IOpt_array_boundsContext is an interface to support dynamic dispatch.
type IOpt_array_boundsContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	AllOPEN_BRACKET() []antlr.TerminalNode
	OPEN_BRACKET(i int) antlr.TerminalNode
	AllCLOSE_BRACKET() []antlr.TerminalNode
	CLOSE_BRACKET(i int) antlr.TerminalNode
	AllIconst() []IIconstContext
	Iconst(i int) IIconstContext

	// IsOpt_array_boundsContext differentiates from other interfaces.
	IsOpt_array_boundsContext()
}

type Opt_array_boundsContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyOpt_array_boundsContext() *Opt_array_boundsContext {
	var p = new(Opt_array_boundsContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opt_array_bounds
	return p
}

func InitEmptyOpt_array_boundsContext(p *Opt_array_boundsContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opt_array_bounds
}

func (*Opt_array_boundsContext) IsOpt_array_boundsContext() {}

func NewOpt_array_boundsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_array_boundsContext {
	var p = new(Opt_array_boundsContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_opt_array_bounds

	return p
}

func (s *Opt_array_boundsContext) GetParser() antlr.Parser { return s.parser }

func (s *Opt_array_boundsContext) AllOPEN_BRACKET() []antlr.TerminalNode {
	return s.GetTokens(PostgreSQLParserOPEN_BRACKET)
}

func (s *Opt_array_boundsContext) OPEN_BRACKET(i int) antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserOPEN_BRACKET, i)
}

func (s *Opt_array_boundsContext) AllCLOSE_BRACKET() []antlr.TerminalNode {
	return s.GetTokens(PostgreSQLParserCLOSE_BRACKET)
}

func (s *Opt_array_boundsContext) CLOSE_BRACKET(i int) antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCLOSE_BRACKET, i)
}

func (s *Opt_array_boundsContext) AllIconst() []IIconstContext {
	children := s.GetChildren()
	len := 0
	for _, ctx := range children {
		if _, ok := ctx.(IIconstContext); ok {
			len++
		}
	}

	tst := make([]IIconstContext, len)
	i := 0
	for _, ctx := range children {
		if t, ok := ctx.(IIconstContext); ok {
			tst[i] = t.(IIconstContext)
			i++
		}
	}

	return tst
}

func (s *Opt_array_boundsContext) Iconst(i int) IIconstContext {
	var t antlr.RuleContext
	j := 0
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IIconstContext); ok {
			if j == i {
				t = ctx.(antlr.RuleContext)
				break
			}
			j++
		}
	}

	if t == nil {
		return nil
	}

	return t.(IIconstContext)
}

func (s *Opt_array_boundsContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Opt_array_boundsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Opt_array_boundsContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterOpt_array_bounds(s)
	}
}

func (s *Opt_array_boundsContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitOpt_array_bounds(s)
	}
}

func (s *Opt_array_boundsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitOpt_array_bounds(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Opt_array_bounds() (localctx IOpt_array_boundsContext) {
	localctx = NewOpt_array_boundsContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1120, PostgreSQLParserRULE_opt_array_bounds)
	var _la int

	var _alt int

	p.EnterOuterAlt(localctx, 1)
	p.SetState(8628)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}
	_alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 519, p.GetParserRuleContext())
	if p.HasError() {
		goto errorExit
	}
	for _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
		if _alt == 1 {
			{
				p.SetState(8621)
				p.Match(PostgreSQLParserOPEN_BRACKET)
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}
			p.SetState(8623)
			p.GetErrorHandler().Sync(p)
			if p.HasError() {
				goto errorExit
			}
			_la = p.GetTokenStream().LA(1)

			if _la == PostgreSQLParserIntegral {
				{
					p.SetState(8622)
					p.Iconst()
				}

			}
			{
				p.SetState(8625)
				p.Match(PostgreSQLParserCLOSE_BRACKET)
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}

		}
		p.SetState(8630)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}
		_alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 519, p.GetParserRuleContext())
		if p.HasError() {
			goto errorExit
		}
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// ISimpletypenameContext is an interface to support dynamic dispatch.
type ISimpletypenameContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Generictype() IGenerictypeContext
	Numeric() INumericContext
	Bit() IBitContext
	Character() ICharacterContext
	Constdatetime() IConstdatetimeContext
	Constinterval() IConstintervalContext
	Opt_interval() IOpt_intervalContext
	OPEN_PAREN() antlr.TerminalNode
	Iconst() IIconstContext
	CLOSE_PAREN() antlr.TerminalNode

	// IsSimpletypenameContext differentiates from other interfaces.
	IsSimpletypenameContext()
}

type SimpletypenameContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptySimpletypenameContext() *SimpletypenameContext {
	var p = new(SimpletypenameContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_simpletypename
	return p
}

func InitEmptySimpletypenameContext(p *SimpletypenameContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_simpletypename
}

func (*SimpletypenameContext) IsSimpletypenameContext() {}

func NewSimpletypenameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SimpletypenameContext {
	var p = new(SimpletypenameContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_simpletypename

	return p
}

func (s *SimpletypenameContext) GetParser() antlr.Parser { return s.parser }

func (s *SimpletypenameContext) Generictype() IGenerictypeContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IGenerictypeContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IGenerictypeContext)
}

func (s *SimpletypenameContext) Numeric() INumericContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(INumericContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(INumericContext)
}

func (s *SimpletypenameContext) Bit() IBitContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IBitContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IBitContext)
}

func (s *SimpletypenameContext) Character() ICharacterContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ICharacterContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ICharacterContext)
}

func (s *SimpletypenameContext) Constdatetime() IConstdatetimeContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IConstdatetimeContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IConstdatetimeContext)
}

func (s *SimpletypenameContext) Constinterval() IConstintervalContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IConstintervalContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IConstintervalContext)
}

func (s *SimpletypenameContext) Opt_interval() IOpt_intervalContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOpt_intervalContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOpt_intervalContext)
}

func (s *SimpletypenameContext) OPEN_PAREN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserOPEN_PAREN, 0)
}

func (s *SimpletypenameContext) Iconst() IIconstContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IIconstContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IIconstContext)
}

func (s *SimpletypenameContext) CLOSE_PAREN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCLOSE_PAREN, 0)
}

func (s *SimpletypenameContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *SimpletypenameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *SimpletypenameContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterSimpletypename(s)
	}
}

func (s *SimpletypenameContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitSimpletypename(s)
	}
}

func (s *SimpletypenameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitSimpletypename(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Simpletypename() (localctx ISimpletypenameContext) {
	localctx = NewSimpletypenameContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1122, PostgreSQLParserRULE_simpletypename)
	p.SetState(8644)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 521, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(8631)
			p.Generictype()
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(8632)
			p.Numeric()
		}

	case 3:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(8633)
			p.Bit()
		}

	case 4:
		p.EnterOuterAlt(localctx, 4)
		{
			p.SetState(8634)
			p.Character()
		}

	case 5:
		p.EnterOuterAlt(localctx, 5)
		{
			p.SetState(8635)
			p.Constdatetime()
		}

	case 6:
		p.EnterOuterAlt(localctx, 6)
		{
			p.SetState(8636)
			p.Constinterval()
		}
		p.SetState(8642)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}

		switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 520, p.GetParserRuleContext()) {
		case 1:
			{
				p.SetState(8637)
				p.Opt_interval()
			}

		case 2:
			{
				p.SetState(8638)
				p.Match(PostgreSQLParserOPEN_PAREN)
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}
			{
				p.SetState(8639)
				p.Iconst()
			}
			{
				p.SetState(8640)
				p.Match(PostgreSQLParserCLOSE_PAREN)
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}

		case antlr.ATNInvalidAltNumber:
			goto errorExit
		}

	case antlr.ATNInvalidAltNumber:
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IConsttypenameContext is an interface to support dynamic dispatch.
type IConsttypenameContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Numeric() INumericContext
	Constbit() IConstbitContext
	Constcharacter() IConstcharacterContext
	Constdatetime() IConstdatetimeContext

	// IsConsttypenameContext differentiates from other interfaces.
	IsConsttypenameContext()
}

type ConsttypenameContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyConsttypenameContext() *ConsttypenameContext {
	var p = new(ConsttypenameContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_consttypename
	return p
}

func InitEmptyConsttypenameContext(p *ConsttypenameContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_consttypename
}

func (*ConsttypenameContext) IsConsttypenameContext() {}

func NewConsttypenameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ConsttypenameContext {
	var p = new(ConsttypenameContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_consttypename

	return p
}

func (s *ConsttypenameContext) GetParser() antlr.Parser { return s.parser }

func (s *ConsttypenameContext) Numeric() INumericContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(INumericContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(INumericContext)
}

func (s *ConsttypenameContext) Constbit() IConstbitContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IConstbitContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IConstbitContext)
}

func (s *ConsttypenameContext) Constcharacter() IConstcharacterContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IConstcharacterContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IConstcharacterContext)
}

func (s *ConsttypenameContext) Constdatetime() IConstdatetimeContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IConstdatetimeContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IConstdatetimeContext)
}

func (s *ConsttypenameContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *ConsttypenameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *ConsttypenameContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterConsttypename(s)
	}
}

func (s *ConsttypenameContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitConsttypename(s)
	}
}

func (s *ConsttypenameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitConsttypename(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Consttypename() (localctx IConsttypenameContext) {
	localctx = NewConsttypenameContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1124, PostgreSQLParserRULE_consttypename)
	p.SetState(8650)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetTokenStream().LA(1) {
	case PostgreSQLParserDOUBLE_P, PostgreSQLParserBIGINT, PostgreSQLParserBOOLEAN_P, PostgreSQLParserDEC, PostgreSQLParserDECIMAL_P, PostgreSQLParserFLOAT_P, PostgreSQLParserINT_P, PostgreSQLParserINTEGER, PostgreSQLParserNUMERIC, PostgreSQLParserREAL, PostgreSQLParserSMALLINT:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(8646)
			p.Numeric()
		}

	case PostgreSQLParserBIT:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(8647)
			p.Constbit()
		}

	case PostgreSQLParserCHAR_P, PostgreSQLParserCHARACTER, PostgreSQLParserNATIONAL, PostgreSQLParserNCHAR, PostgreSQLParserVARCHAR:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(8648)
			p.Constcharacter()
		}

	case PostgreSQLParserTIME, PostgreSQLParserTIMESTAMP:
		p.EnterOuterAlt(localctx, 4)
		{
			p.SetState(8649)
			p.Constdatetime()
		}

	default:
		p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IGenerictypeContext is an interface to support dynamic dispatch.
type IGenerictypeContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Opt_type_modifiers() IOpt_type_modifiersContext
	Builtin_function_name() IBuiltin_function_nameContext
	Type_function_name() IType_function_nameContext
	LEFT() antlr.TerminalNode
	RIGHT() antlr.TerminalNode
	Attrs() IAttrsContext

	// IsGenerictypeContext differentiates from other interfaces.
	IsGenerictypeContext()
}

type GenerictypeContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyGenerictypeContext() *GenerictypeContext {
	var p = new(GenerictypeContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_generictype
	return p
}

func InitEmptyGenerictypeContext(p *GenerictypeContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_generictype
}

func (*GenerictypeContext) IsGenerictypeContext() {}

func NewGenerictypeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *GenerictypeContext {
	var p = new(GenerictypeContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_generictype

	return p
}

func (s *GenerictypeContext) GetParser() antlr.Parser { return s.parser }

func (s *GenerictypeContext) Opt_type_modifiers() IOpt_type_modifiersContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOpt_type_modifiersContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOpt_type_modifiersContext)
}

func (s *GenerictypeContext) Builtin_function_name() IBuiltin_function_nameContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IBuiltin_function_nameContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IBuiltin_function_nameContext)
}

func (s *GenerictypeContext) Type_function_name() IType_function_nameContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IType_function_nameContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IType_function_nameContext)
}

func (s *GenerictypeContext) LEFT() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserLEFT, 0)
}

func (s *GenerictypeContext) RIGHT() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserRIGHT, 0)
}

func (s *GenerictypeContext) Attrs() IAttrsContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IAttrsContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IAttrsContext)
}

func (s *GenerictypeContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *GenerictypeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *GenerictypeContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterGenerictype(s)
	}
}

func (s *GenerictypeContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitGenerictype(s)
	}
}

func (s *GenerictypeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitGenerictype(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Generictype() (localctx IGenerictypeContext) {
	localctx = NewGenerictypeContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1126, PostgreSQLParserRULE_generictype)
	p.EnterOuterAlt(localctx, 1)
	p.SetState(8656)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetTokenStream().LA(1) {
	case PostgreSQLParserREPLACE, PostgreSQLParserXMLCOMMENT, PostgreSQLParserXMLAGG, PostgreSQLParserXML_IS_WELL_FORMED, PostgreSQLParserXML_IS_WELL_FORMED_DOCUMENT, PostgreSQLParserXML_IS_WELL_FORMED_CONTENT, PostgreSQLParserXPATH, PostgreSQLParserXPATH_EXISTS, PostgreSQLParserREVERSE, PostgreSQLParserLOG, PostgreSQLParserABS, PostgreSQLParserCBRT, PostgreSQLParserCEIL, PostgreSQLParserCEILING, PostgreSQLParserDEGREES, PostgreSQLParserDIV, PostgreSQLParserEXP, PostgreSQLParserFACTORIAL, PostgreSQLParserFLOOR, PostgreSQLParserGCD, PostgreSQLParserLCM, PostgreSQLParserLN, PostgreSQLParserLOG10, PostgreSQLParserMIN_SCALE, PostgreSQLParserMOD, PostgreSQLParserPI, PostgreSQLParserPOWER, PostgreSQLParserRADIANS, PostgreSQLParserROUND, PostgreSQLParserSCALE, PostgreSQLParserSIGN, PostgreSQLParserSQRT, PostgreSQLParserTRIM_SCALE, PostgreSQLParserTRUNC, PostgreSQLParserWIDTH_BUCKET, PostgreSQLParserRANDOM, PostgreSQLParserSETSEED, PostgreSQLParserACOS, PostgreSQLParserACOSD, PostgreSQLParserASIN, PostgreSQLParserASIND, PostgreSQLParserATAN, PostgreSQLParserATAND, PostgreSQLParserATAN2, PostgreSQLParserATAN2D, PostgreSQLParserCOS, PostgreSQLParserCOSD, PostgreSQLParserCOT, PostgreSQLParserCOTD, PostgreSQLParserSIN, PostgreSQLParserSIND, PostgreSQLParserTAN, PostgreSQLParserTAND, PostgreSQLParserSINH, PostgreSQLParserCOSH, PostgreSQLParserTANH, PostgreSQLParserASINH, PostgreSQLParserACOSH, PostgreSQLParserATANH, PostgreSQLParserBIT_LENGTH, PostgreSQLParserCHAR_LENGTH, PostgreSQLParserCHARACTER_LENGTH, PostgreSQLParserLOWER, PostgreSQLParserOCTET_LENGTH, PostgreSQLParserUPPER, PostgreSQLParserASCII, PostgreSQLParserBTRIM, PostgreSQLParserCHR, PostgreSQLParserCONCAT, PostgreSQLParserCONCAT_WS, PostgreSQLParserFORMAT, PostgreSQLParserINITCAP, PostgreSQLParserLENGTH, PostgreSQLParserLPAD, PostgreSQLParserLTRIM, PostgreSQLParserMD5, PostgreSQLParserPARSE_IDENT, PostgreSQLParserPG_CLIENT_ENCODING, PostgreSQLParserQUOTE_IDENT, PostgreSQLParserQUOTE_LITERAL, PostgreSQLParserQUOTE_NULLABLE, PostgreSQLParserREGEXP_COUNT, PostgreSQLParserREGEXP_INSTR, PostgreSQLParserREGEXP_LIKE, PostgreSQLParserREGEXP_MATCH, PostgreSQLParserREGEXP_MATCHES, PostgreSQLParserREGEXP_REPLACE, PostgreSQLParserREGEXP_SPLIT_TO_ARRAY, PostgreSQLParserREGEXP_SPLIT_TO_TABLE, PostgreSQLParserREGEXP_SUBSTR, PostgreSQLParserREPEAT, PostgreSQLParserRPAD, PostgreSQLParserRTRIM, PostgreSQLParserSPLIT_PART, PostgreSQLParserSTARTS_WITH, PostgreSQLParserSTRING_TO_ARRAY, PostgreSQLParserSTRING_TO_TABLE, PostgreSQLParserSTRPOS, PostgreSQLParserSUBSTR, PostgreSQLParserTO_ASCII, PostgreSQLParserTO_HEX, PostgreSQLParserTRANSLATE, PostgreSQLParserUNISTR, PostgreSQLParserAGE, PostgreSQLParserCLOCK_TIMESTAMP, PostgreSQLParserDATE_BIN, PostgreSQLParserDATE_PART, PostgreSQLParserDATE_TRUNC, PostgreSQLParserISFINITE, PostgreSQLParserJUSTIFY_DAYS, PostgreSQLParserJUSTIFY_HOURS, PostgreSQLParserJUSTIFY_INTERVAL, PostgreSQLParserMAKE_DATE, PostgreSQLParserMAKE_INTERVAL, PostgreSQLParserMAKE_TIME, PostgreSQLParserMAKE_TIMESTAMP, PostgreSQLParserMAKE_TIMESTAMPTZ, PostgreSQLParserNOW, PostgreSQLParserSTATEMENT_TIMESTAMP, PostgreSQLParserTIMEOFDAY, PostgreSQLParserTRANSACTION_TIMESTAMP, PostgreSQLParserTO_TIMESTAMP, PostgreSQLParserTO_CHAR, PostgreSQLParserTO_DATE, PostgreSQLParserTO_NUMBER:
		{
			p.SetState(8652)
			p.Builtin_function_name()
		}

	case PostgreSQLParserAND, PostgreSQLParserARRAY, PostgreSQLParserCOLLATE, PostgreSQLParserCOLUMN, PostgreSQLParserCONSTRAINT, PostgreSQLParserDEFAULT, PostgreSQLParserDO, PostgreSQLParserFETCH, PostgreSQLParserTABLE, PostgreSQLParserAUTHORIZATION, PostgreSQLParserBINARY, PostgreSQLParserCOLLATION, PostgreSQLParserCONCURRENTLY, PostgreSQLParserCROSS, PostgreSQLParserCURRENT_SCHEMA, PostgreSQLParserFREEZE, PostgreSQLParserFULL, PostgreSQLParserILIKE, PostgreSQLParserINNER_P, PostgreSQLParserIS, PostgreSQLParserISNULL, PostgreSQLParserJOIN, PostgreSQLParserLIKE, PostgreSQLParserNATURAL, PostgreSQLParserNOTNULL, PostgreSQLParserOUTER_P, PostgreSQLParserOVER, PostgreSQLParserOVERLAPS, PostgreSQLParserSIMILAR, PostgreSQLParserVERBOSE, PostgreSQLParserABORT_P, PostgreSQLParserABSOLUTE_P, PostgreSQLParserACCESS, PostgreSQLParserACTION, PostgreSQLParserADD_P, PostgreSQLParserADMIN, PostgreSQLParserAFTER, PostgreSQLParserAGGREGATE, PostgreSQLParserALSO, PostgreSQLParserALTER, PostgreSQLParserALWAYS, PostgreSQLParserASSERTION, PostgreSQLParserASSIGNMENT, PostgreSQLParserAT, PostgreSQLParserATTRIBUTE, PostgreSQLParserBACKWARD, PostgreSQLParserBEFORE, PostgreSQLParserBEGIN_P, PostgreSQLParserBY, PostgreSQLParserCACHE, PostgreSQLParserCALLED, PostgreSQLParserCASCADE, PostgreSQLParserCASCADED, PostgreSQLParserCATALOG, PostgreSQLParserCHAIN, PostgreSQLParserCHARACTERISTICS, PostgreSQLParserCHECKPOINT, PostgreSQLParserCLASS, PostgreSQLParserCLOSE, PostgreSQLParserCLUSTER, PostgreSQLParserCOMMENT, PostgreSQLParserCOMMENTS, PostgreSQLParserCOMMIT, PostgreSQLParserCOMMITTED, PostgreSQLParserCONFIGURATION, PostgreSQLParserCONNECTION, PostgreSQLParserCONSTRAINTS, PostgreSQLParserCONTENT_P, PostgreSQLParserCONTINUE_P, PostgreSQLParserCONVERSION_P, PostgreSQLParserCOPY, PostgreSQLParserCOST, PostgreSQLParserCSV, PostgreSQLParserCURSOR, PostgreSQLParserCYCLE, PostgreSQLParserDATA_P, PostgreSQLParserDATABASE, PostgreSQLParserDAY_P, PostgreSQLParserDEALLOCATE, PostgreSQLParserDECLARE, PostgreSQLParserDEFAULTS, PostgreSQLParserDEFERRED, PostgreSQLParserDEFINER, PostgreSQLParserDELETE_P, PostgreSQLParserDELIMITER, PostgreSQLParserDELIMITERS, PostgreSQLParserDICTIONARY, PostgreSQLParserDISABLE_P, PostgreSQLParserDISCARD, PostgreSQLParserDOCUMENT_P, PostgreSQLParserDOMAIN_P, PostgreSQLParserDOUBLE_P, PostgreSQLParserDROP, PostgreSQLParserEACH, PostgreSQLParserENABLE_P, PostgreSQLParserENCODING, PostgreSQLParserENCRYPTED, PostgreSQLParserENUM_P, PostgreSQLParserESCAPE, PostgreSQLParserEVENT, PostgreSQLParserEXCLUDE, PostgreSQLParserEXCLUDING, PostgreSQLParserEXCLUSIVE, PostgreSQLParserEXECUTE, PostgreSQLParserEXPLAIN, PostgreSQLParserEXTENSION, PostgreSQLParserEXTERNAL, PostgreSQLParserFAMILY, PostgreSQLParserFIRST_P, PostgreSQLParserFOLLOWING, PostgreSQLParserFORCE, PostgreSQLParserFORWARD, PostgreSQLParserFUNCTION, PostgreSQLParserFUNCTIONS, PostgreSQLParserGLOBAL, PostgreSQLParserGRANTED, PostgreSQLParserHANDLER, PostgreSQLParserHEADER_P, PostgreSQLParserHOLD, PostgreSQLParserHOUR_P, PostgreSQLParserIDENTITY_P, PostgreSQLParserIF_P, PostgreSQLParserIMMEDIATE, PostgreSQLParserIMMUTABLE, PostgreSQLParserIMPLICIT_P, PostgreSQLParserINCLUDING, PostgreSQLParserINCREMENT, PostgreSQLParserINDEX, PostgreSQLParserINDEXES, PostgreSQLParserINHERIT, PostgreSQLParserINHERITS, PostgreSQLParserINLINE_P, PostgreSQLParserINSENSITIVE, PostgreSQLParserINSERT, PostgreSQLParserINSTEAD, PostgreSQLParserINVOKER, PostgreSQLParserISOLATION, PostgreSQLParserKEY, PostgreSQLParserLABEL, PostgreSQLParserLANGUAGE, PostgreSQLParserLARGE_P, PostgreSQLParserLAST_P, PostgreSQLParserLEAKPROOF, PostgreSQLParserLEVEL, PostgreSQLParserLISTEN, PostgreSQLParserLOAD, PostgreSQLParserLOCAL, PostgreSQLParserLOCATION, PostgreSQLParserLOCK_P, PostgreSQLParserMAPPING, PostgreSQLParserMATCH, PostgreSQLParserMATERIALIZED, PostgreSQLParserMAXVALUE, PostgreSQLParserMINUTE_P, PostgreSQLParserMINVALUE, PostgreSQLParserMODE, PostgreSQLParserMONTH_P, PostgreSQLParserMOVE, PostgreSQLParserNAME_P, PostgreSQLParserNAMES, PostgreSQLParserNEXT, PostgreSQLParserNO, PostgreSQLParserNOTHING, PostgreSQLParserNOTIFY, PostgreSQLParserNOWAIT, PostgreSQLParserNULLS_P, PostgreSQLParserOBJECT_P, PostgreSQLParserOF, PostgreSQLParserOFF, PostgreSQLParserOIDS, PostgreSQLParserOPERATOR, PostgreSQLParserOPTION, PostgreSQLParserOPTIONS, PostgreSQLParserOWNED, PostgreSQLParserOWNER, PostgreSQLParserPARSER, PostgreSQLParserPARTIAL, PostgreSQLParserPARTITION, PostgreSQLParserPASSING, PostgreSQLParserPASSWORD, PostgreSQLParserPLANS, PostgreSQLParserPRECEDING, PostgreSQLParserPREPARE, PostgreSQLParserPREPARED, PostgreSQLParserPRESERVE, PostgreSQLParserPRIOR, PostgreSQLParserPRIVILEGES, PostgreSQLParserPROCEDURAL, PostgreSQLParserPROCEDURE, PostgreSQLParserPROGRAM, PostgreSQLParserQUOTE, PostgreSQLParserRANGE, PostgreSQLParserREAD, PostgreSQLParserREASSIGN, PostgreSQLParserRECHECK, PostgreSQLParserRECURSIVE, PostgreSQLParserREF, PostgreSQLParserREFRESH, PostgreSQLParserREINDEX, PostgreSQLParserRELATIVE_P, PostgreSQLParserRELEASE, PostgreSQLParserRENAME, PostgreSQLParserREPEATABLE, PostgreSQLParserREPLICA, PostgreSQLParserRESET, PostgreSQLParserRESTART, PostgreSQLParserRESTRICT, PostgreSQLParserRETURNS, PostgreSQLParserREVOKE, PostgreSQLParserROLE, PostgreSQLParserROLLBACK, PostgreSQLParserROWS, PostgreSQLParserRULE, PostgreSQLParserSAVEPOINT, PostgreSQLParserSCHEMA, PostgreSQLParserSCROLL, PostgreSQLParserSEARCH, PostgreSQLParserSECOND_P, PostgreSQLParserSECURITY, PostgreSQLParserSEQUENCE, PostgreSQLParserSEQUENCES, PostgreSQLParserSERIALIZABLE, PostgreSQLParserSERVER, PostgreSQLParserSESSION, PostgreSQLParserSET, PostgreSQLParserSHARE, PostgreSQLParserSHOW, PostgreSQLParserSIMPLE, PostgreSQLParserSNAPSHOT, PostgreSQLParserSTABLE, PostgreSQLParserSTANDALONE_P, PostgreSQLParserSTART, PostgreSQLParserSTATEMENT, PostgreSQLParserSTATISTICS, PostgreSQLParserSTDIN, PostgreSQLParserSTDOUT, PostgreSQLParserSTORAGE, PostgreSQLParserSTRICT_P, PostgreSQLParserSTRIP_P, PostgreSQLParserSYSID, PostgreSQLParserSYSTEM_P, PostgreSQLParserTABLES, PostgreSQLParserTABLESPACE, PostgreSQLParserTEMP, PostgreSQLParserTEMPLATE, PostgreSQLParserTEMPORARY, PostgreSQLParserTEXT_P, PostgreSQLParserTRANSACTION, PostgreSQLParserTRIGGER, PostgreSQLParserTRUNCATE, PostgreSQLParserTRUSTED, PostgreSQLParserTYPE_P, PostgreSQLParserTYPES_P, PostgreSQLParserUNBOUNDED, PostgreSQLParserUNCOMMITTED, PostgreSQLParserUNENCRYPTED, PostgreSQLParserUNKNOWN, PostgreSQLParserUNLISTEN, PostgreSQLParserUNLOGGED, PostgreSQLParserUNTIL, PostgreSQLParserUPDATE, PostgreSQLParserVACUUM, PostgreSQLParserVALID, PostgreSQLParserVALIDATE, PostgreSQLParserVALIDATOR, PostgreSQLParserVARYING, PostgreSQLParserVERSION_P, PostgreSQLParserVIEW, PostgreSQLParserVOLATILE, PostgreSQLParserWHITESPACE_P, PostgreSQLParserWITHOUT, PostgreSQLParserWORK, PostgreSQLParserWRAPPER, PostgreSQLParserWRITE, PostgreSQLParserXML_P, PostgreSQLParserYEAR_P, PostgreSQLParserYES_P, PostgreSQLParserZONE, PostgreSQLParserCALL, PostgreSQLParserCURRENT_P, PostgreSQLParserATTACH, PostgreSQLParserDETACH, PostgreSQLParserEXPRESSION, PostgreSQLParserGENERATED, PostgreSQLParserLOGGED, PostgreSQLParserSTORED, PostgreSQLParserINCLUDE, PostgreSQLParserROUTINE, PostgreSQLParserTRANSFORM, PostgreSQLParserIMPORT_P, PostgreSQLParserPOLICY, PostgreSQLParserMETHOD, PostgreSQLParserREFERENCING, PostgreSQLParserNEW, PostgreSQLParserOLD, PostgreSQLParserVALUE_P, PostgreSQLParserSUBSCRIPTION, PostgreSQLParserPUBLICATION, PostgreSQLParserROUTINES, PostgreSQLParserSCHEMAS, PostgreSQLParserPROCEDURES, PostgreSQLParserINPUT_P, PostgreSQLParserSUPPORT, PostgreSQLParserPARALLEL, PostgreSQLParserSQL_P, PostgreSQLParserDEPENDS, PostgreSQLParserOVERRIDING, PostgreSQLParserCONFLICT, PostgreSQLParserSKIP_P, PostgreSQLParserLOCKED, PostgreSQLParserTIES, PostgreSQLParserROLLUP, PostgreSQLParserCUBE, PostgreSQLParserSETS, PostgreSQLParserTABLESAMPLE, PostgreSQLParserORDINALITY, PostgreSQLParserCOLUMNS, PostgreSQLParserROWTYPE, PostgreSQLParserNORMALIZED, PostgreSQLParserWITHIN, PostgreSQLParserFILTER, PostgreSQLParserGROUPS, PostgreSQLParserOTHERS, PostgreSQLParserNFC, PostgreSQLParserNFD, PostgreSQLParserNFKC, PostgreSQLParserNFKD, PostgreSQLParserUESCAPE, PostgreSQLParserVIEWS, PostgreSQLParserDUMP, PostgreSQLParserPRINT_STRICT_PARAMS, PostgreSQLParserVARIABLE_CONFLICT, PostgreSQLParserERROR, PostgreSQLParserUSE_VARIABLE, PostgreSQLParserUSE_COLUMN, PostgreSQLParserALIAS, PostgreSQLParserCONSTANT, PostgreSQLParserPERFORM, PostgreSQLParserGET, PostgreSQLParserDIAGNOSTICS, PostgreSQLParserSTACKED, PostgreSQLParserELSIF, PostgreSQLParserSLICE, PostgreSQLParserEXIT, PostgreSQLParserRETURN, PostgreSQLParserQUERY, PostgreSQLParserRAISE, PostgreSQLParserSQLSTATE, PostgreSQLParserDEBUG, PostgreSQLParserINFO, PostgreSQLParserNOTICE, PostgreSQLParserWARNING, PostgreSQLParserEXCEPTION, PostgreSQLParserASSERT, PostgreSQLParserOPEN, PostgreSQLParserIdentifier, PostgreSQLParserQuotedIdentifier, PostgreSQLParserUnicodeQuotedIdentifier, PostgreSQLParserPLSQLVARIABLENAME, PostgreSQLParserPLSQLIDENTIFIER:
		{
			p.SetState(8653)
			p.Type_function_name()
		}

	case PostgreSQLParserLEFT:
		{
			p.SetState(8654)
			p.Match(PostgreSQLParserLEFT)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case PostgreSQLParserRIGHT:
		{
			p.SetState(8655)
			p.Match(PostgreSQLParserRIGHT)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	default:
		p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		goto errorExit
	}
	p.SetState(8659)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 524, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(8658)
			p.Attrs()
		}

	} else if p.HasError() { // JIM
		goto errorExit
	}
	{
		p.SetState(8661)
		p.Opt_type_modifiers()
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IOpt_type_modifiersContext is an interface to support dynamic dispatch.
type IOpt_type_modifiersContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	OPEN_PAREN() antlr.TerminalNode
	Expr_list() IExpr_listContext
	CLOSE_PAREN() antlr.TerminalNode

	// IsOpt_type_modifiersContext differentiates from other interfaces.
	IsOpt_type_modifiersContext()
}

type Opt_type_modifiersContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyOpt_type_modifiersContext() *Opt_type_modifiersContext {
	var p = new(Opt_type_modifiersContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opt_type_modifiers
	return p
}

func InitEmptyOpt_type_modifiersContext(p *Opt_type_modifiersContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opt_type_modifiers
}

func (*Opt_type_modifiersContext) IsOpt_type_modifiersContext() {}

func NewOpt_type_modifiersContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_type_modifiersContext {
	var p = new(Opt_type_modifiersContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_opt_type_modifiers

	return p
}

func (s *Opt_type_modifiersContext) GetParser() antlr.Parser { return s.parser }

func (s *Opt_type_modifiersContext) OPEN_PAREN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserOPEN_PAREN, 0)
}

func (s *Opt_type_modifiersContext) Expr_list() IExpr_listContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IExpr_listContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IExpr_listContext)
}

func (s *Opt_type_modifiersContext) CLOSE_PAREN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCLOSE_PAREN, 0)
}

func (s *Opt_type_modifiersContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Opt_type_modifiersContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Opt_type_modifiersContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterOpt_type_modifiers(s)
	}
}

func (s *Opt_type_modifiersContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitOpt_type_modifiers(s)
	}
}

func (s *Opt_type_modifiersContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitOpt_type_modifiers(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Opt_type_modifiers() (localctx IOpt_type_modifiersContext) {
	localctx = NewOpt_type_modifiersContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1128, PostgreSQLParserRULE_opt_type_modifiers)
	p.SetState(8668)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 525, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(8663)
			p.Match(PostgreSQLParserOPEN_PAREN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(8664)
			p.Expr_list()
		}
		{
			p.SetState(8665)
			p.Match(PostgreSQLParserCLOSE_PAREN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)

	case antlr.ATNInvalidAltNumber:
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// INumericContext is an interface to support dynamic dispatch.
type INumericContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	INT_P() antlr.TerminalNode
	INTEGER() antlr.TerminalNode
	SMALLINT() antlr.TerminalNode
	BIGINT() antlr.TerminalNode
	REAL() antlr.TerminalNode
	FLOAT_P() antlr.TerminalNode
	Opt_float() IOpt_floatContext
	DOUBLE_P() antlr.TerminalNode
	PRECISION() antlr.TerminalNode
	DECIMAL_P() antlr.TerminalNode
	Opt_type_modifiers() IOpt_type_modifiersContext
	DEC() antlr.TerminalNode
	NUMERIC() antlr.TerminalNode
	BOOLEAN_P() antlr.TerminalNode

	// IsNumericContext differentiates from other interfaces.
	IsNumericContext()
}

type NumericContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyNumericContext() *NumericContext {
	var p = new(NumericContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_numeric
	return p
}

func InitEmptyNumericContext(p *NumericContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_numeric
}

func (*NumericContext) IsNumericContext() {}

func NewNumericContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *NumericContext {
	var p = new(NumericContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_numeric

	return p
}

func (s *NumericContext) GetParser() antlr.Parser { return s.parser }

func (s *NumericContext) INT_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserINT_P, 0)
}

func (s *NumericContext) INTEGER() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserINTEGER, 0)
}

func (s *NumericContext) SMALLINT() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserSMALLINT, 0)
}

func (s *NumericContext) BIGINT() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserBIGINT, 0)
}

func (s *NumericContext) REAL() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserREAL, 0)
}

func (s *NumericContext) FLOAT_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserFLOAT_P, 0)
}

func (s *NumericContext) Opt_float() IOpt_floatContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOpt_floatContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOpt_floatContext)
}

func (s *NumericContext) DOUBLE_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserDOUBLE_P, 0)
}

func (s *NumericContext) PRECISION() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserPRECISION, 0)
}

func (s *NumericContext) DECIMAL_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserDECIMAL_P, 0)
}

func (s *NumericContext) Opt_type_modifiers() IOpt_type_modifiersContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOpt_type_modifiersContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOpt_type_modifiersContext)
}

func (s *NumericContext) DEC() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserDEC, 0)
}

func (s *NumericContext) NUMERIC() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserNUMERIC, 0)
}

func (s *NumericContext) BOOLEAN_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserBOOLEAN_P, 0)
}

func (s *NumericContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *NumericContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *NumericContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterNumeric(s)
	}
}

func (s *NumericContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitNumeric(s)
	}
}

func (s *NumericContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitNumeric(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Numeric() (localctx INumericContext) {
	localctx = NewNumericContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1130, PostgreSQLParserRULE_numeric)
	p.SetState(8686)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetTokenStream().LA(1) {
	case PostgreSQLParserINT_P:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(8670)
			p.Match(PostgreSQLParserINT_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case PostgreSQLParserINTEGER:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(8671)
			p.Match(PostgreSQLParserINTEGER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case PostgreSQLParserSMALLINT:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(8672)
			p.Match(PostgreSQLParserSMALLINT)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case PostgreSQLParserBIGINT:
		p.EnterOuterAlt(localctx, 4)
		{
			p.SetState(8673)
			p.Match(PostgreSQLParserBIGINT)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case PostgreSQLParserREAL:
		p.EnterOuterAlt(localctx, 5)
		{
			p.SetState(8674)
			p.Match(PostgreSQLParserREAL)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case PostgreSQLParserFLOAT_P:
		p.EnterOuterAlt(localctx, 6)
		{
			p.SetState(8675)
			p.Match(PostgreSQLParserFLOAT_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(8676)
			p.Opt_float()
		}

	case PostgreSQLParserDOUBLE_P:
		p.EnterOuterAlt(localctx, 7)
		{
			p.SetState(8677)
			p.Match(PostgreSQLParserDOUBLE_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(8678)
			p.Match(PostgreSQLParserPRECISION)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case PostgreSQLParserDECIMAL_P:
		p.EnterOuterAlt(localctx, 8)
		{
			p.SetState(8679)
			p.Match(PostgreSQLParserDECIMAL_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(8680)
			p.Opt_type_modifiers()
		}

	case PostgreSQLParserDEC:
		p.EnterOuterAlt(localctx, 9)
		{
			p.SetState(8681)
			p.Match(PostgreSQLParserDEC)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(8682)
			p.Opt_type_modifiers()
		}

	case PostgreSQLParserNUMERIC:
		p.EnterOuterAlt(localctx, 10)
		{
			p.SetState(8683)
			p.Match(PostgreSQLParserNUMERIC)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(8684)
			p.Opt_type_modifiers()
		}

	case PostgreSQLParserBOOLEAN_P:
		p.EnterOuterAlt(localctx, 11)
		{
			p.SetState(8685)
			p.Match(PostgreSQLParserBOOLEAN_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	default:
		p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IOpt_floatContext is an interface to support dynamic dispatch.
type IOpt_floatContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	OPEN_PAREN() antlr.TerminalNode
	Iconst() IIconstContext
	CLOSE_PAREN() antlr.TerminalNode

	// IsOpt_floatContext differentiates from other interfaces.
	IsOpt_floatContext()
}

type Opt_floatContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyOpt_floatContext() *Opt_floatContext {
	var p = new(Opt_floatContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opt_float
	return p
}

func InitEmptyOpt_floatContext(p *Opt_floatContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opt_float
}

func (*Opt_floatContext) IsOpt_floatContext() {}

func NewOpt_floatContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_floatContext {
	var p = new(Opt_floatContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_opt_float

	return p
}

func (s *Opt_floatContext) GetParser() antlr.Parser { return s.parser }

func (s *Opt_floatContext) OPEN_PAREN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserOPEN_PAREN, 0)
}

func (s *Opt_floatContext) Iconst() IIconstContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IIconstContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IIconstContext)
}

func (s *Opt_floatContext) CLOSE_PAREN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCLOSE_PAREN, 0)
}

func (s *Opt_floatContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Opt_floatContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Opt_floatContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterOpt_float(s)
	}
}

func (s *Opt_floatContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitOpt_float(s)
	}
}

func (s *Opt_floatContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitOpt_float(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Opt_float() (localctx IOpt_floatContext) {
	localctx = NewOpt_floatContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1132, PostgreSQLParserRULE_opt_float)
	p.SetState(8693)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 527, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(8688)
			p.Match(PostgreSQLParserOPEN_PAREN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(8689)
			p.Iconst()
		}
		{
			p.SetState(8690)
			p.Match(PostgreSQLParserCLOSE_PAREN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)

	case antlr.ATNInvalidAltNumber:
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IBitContext is an interface to support dynamic dispatch.
type IBitContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Bitwithlength() IBitwithlengthContext
	Bitwithoutlength() IBitwithoutlengthContext

	// IsBitContext differentiates from other interfaces.
	IsBitContext()
}

type BitContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyBitContext() *BitContext {
	var p = new(BitContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_bit
	return p
}

func InitEmptyBitContext(p *BitContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_bit
}

func (*BitContext) IsBitContext() {}

func NewBitContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *BitContext {
	var p = new(BitContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_bit

	return p
}

func (s *BitContext) GetParser() antlr.Parser { return s.parser }

func (s *BitContext) Bitwithlength() IBitwithlengthContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IBitwithlengthContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IBitwithlengthContext)
}

func (s *BitContext) Bitwithoutlength() IBitwithoutlengthContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IBitwithoutlengthContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IBitwithoutlengthContext)
}

func (s *BitContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *BitContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *BitContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterBit(s)
	}
}

func (s *BitContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitBit(s)
	}
}

func (s *BitContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitBit(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Bit() (localctx IBitContext) {
	localctx = NewBitContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1134, PostgreSQLParserRULE_bit)
	p.SetState(8697)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 528, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(8695)
			p.Bitwithlength()
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(8696)
			p.Bitwithoutlength()
		}

	case antlr.ATNInvalidAltNumber:
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IConstbitContext is an interface to support dynamic dispatch.
type IConstbitContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Bitwithlength() IBitwithlengthContext
	Bitwithoutlength() IBitwithoutlengthContext

	// IsConstbitContext differentiates from other interfaces.
	IsConstbitContext()
}

type ConstbitContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyConstbitContext() *ConstbitContext {
	var p = new(ConstbitContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_constbit
	return p
}

func InitEmptyConstbitContext(p *ConstbitContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_constbit
}

func (*ConstbitContext) IsConstbitContext() {}

func NewConstbitContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ConstbitContext {
	var p = new(ConstbitContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_constbit

	return p
}

func (s *ConstbitContext) GetParser() antlr.Parser { return s.parser }

func (s *ConstbitContext) Bitwithlength() IBitwithlengthContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IBitwithlengthContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IBitwithlengthContext)
}

func (s *ConstbitContext) Bitwithoutlength() IBitwithoutlengthContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IBitwithoutlengthContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IBitwithoutlengthContext)
}

func (s *ConstbitContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *ConstbitContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *ConstbitContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterConstbit(s)
	}
}

func (s *ConstbitContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitConstbit(s)
	}
}

func (s *ConstbitContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitConstbit(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Constbit() (localctx IConstbitContext) {
	localctx = NewConstbitContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1136, PostgreSQLParserRULE_constbit)
	p.SetState(8701)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 529, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(8699)
			p.Bitwithlength()
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(8700)
			p.Bitwithoutlength()
		}

	case antlr.ATNInvalidAltNumber:
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IBitwithlengthContext is an interface to support dynamic dispatch.
type IBitwithlengthContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	BIT() antlr.TerminalNode
	Opt_varying() IOpt_varyingContext
	OPEN_PAREN() antlr.TerminalNode
	Expr_list() IExpr_listContext
	CLOSE_PAREN() antlr.TerminalNode

	// IsBitwithlengthContext differentiates from other interfaces.
	IsBitwithlengthContext()
}

type BitwithlengthContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyBitwithlengthContext() *BitwithlengthContext {
	var p = new(BitwithlengthContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_bitwithlength
	return p
}

func InitEmptyBitwithlengthContext(p *BitwithlengthContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_bitwithlength
}

func (*BitwithlengthContext) IsBitwithlengthContext() {}

func NewBitwithlengthContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *BitwithlengthContext {
	var p = new(BitwithlengthContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_bitwithlength

	return p
}

func (s *BitwithlengthContext) GetParser() antlr.Parser { return s.parser }

func (s *BitwithlengthContext) BIT() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserBIT, 0)
}

func (s *BitwithlengthContext) Opt_varying() IOpt_varyingContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOpt_varyingContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOpt_varyingContext)
}

func (s *BitwithlengthContext) OPEN_PAREN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserOPEN_PAREN, 0)
}

func (s *BitwithlengthContext) Expr_list() IExpr_listContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IExpr_listContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IExpr_listContext)
}

func (s *BitwithlengthContext) CLOSE_PAREN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCLOSE_PAREN, 0)
}

func (s *BitwithlengthContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *BitwithlengthContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *BitwithlengthContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterBitwithlength(s)
	}
}

func (s *BitwithlengthContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitBitwithlength(s)
	}
}

func (s *BitwithlengthContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitBitwithlength(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Bitwithlength() (localctx IBitwithlengthContext) {
	localctx = NewBitwithlengthContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1138, PostgreSQLParserRULE_bitwithlength)
	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(8703)
		p.Match(PostgreSQLParserBIT)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(8704)
		p.Opt_varying()
	}
	{
		p.SetState(8705)
		p.Match(PostgreSQLParserOPEN_PAREN)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(8706)
		p.Expr_list()
	}
	{
		p.SetState(8707)
		p.Match(PostgreSQLParserCLOSE_PAREN)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IBitwithoutlengthContext is an interface to support dynamic dispatch.
type IBitwithoutlengthContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	BIT() antlr.TerminalNode
	Opt_varying() IOpt_varyingContext

	// IsBitwithoutlengthContext differentiates from other interfaces.
	IsBitwithoutlengthContext()
}

type BitwithoutlengthContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyBitwithoutlengthContext() *BitwithoutlengthContext {
	var p = new(BitwithoutlengthContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_bitwithoutlength
	return p
}

func InitEmptyBitwithoutlengthContext(p *BitwithoutlengthContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_bitwithoutlength
}

func (*BitwithoutlengthContext) IsBitwithoutlengthContext() {}

func NewBitwithoutlengthContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *BitwithoutlengthContext {
	var p = new(BitwithoutlengthContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_bitwithoutlength

	return p
}

func (s *BitwithoutlengthContext) GetParser() antlr.Parser { return s.parser }

func (s *BitwithoutlengthContext) BIT() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserBIT, 0)
}

func (s *BitwithoutlengthContext) Opt_varying() IOpt_varyingContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOpt_varyingContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOpt_varyingContext)
}

func (s *BitwithoutlengthContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *BitwithoutlengthContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *BitwithoutlengthContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterBitwithoutlength(s)
	}
}

func (s *BitwithoutlengthContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitBitwithoutlength(s)
	}
}

func (s *BitwithoutlengthContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitBitwithoutlength(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Bitwithoutlength() (localctx IBitwithoutlengthContext) {
	localctx = NewBitwithoutlengthContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1140, PostgreSQLParserRULE_bitwithoutlength)
	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(8709)
		p.Match(PostgreSQLParserBIT)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(8710)
		p.Opt_varying()
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// ICharacterContext is an interface to support dynamic dispatch.
type ICharacterContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Character_c() ICharacter_cContext
	OPEN_PAREN() antlr.TerminalNode
	Iconst() IIconstContext
	CLOSE_PAREN() antlr.TerminalNode

	// IsCharacterContext differentiates from other interfaces.
	IsCharacterContext()
}

type CharacterContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyCharacterContext() *CharacterContext {
	var p = new(CharacterContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_character
	return p
}

func InitEmptyCharacterContext(p *CharacterContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_character
}

func (*CharacterContext) IsCharacterContext() {}

func NewCharacterContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CharacterContext {
	var p = new(CharacterContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_character

	return p
}

func (s *CharacterContext) GetParser() antlr.Parser { return s.parser }

func (s *CharacterContext) Character_c() ICharacter_cContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ICharacter_cContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ICharacter_cContext)
}

func (s *CharacterContext) OPEN_PAREN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserOPEN_PAREN, 0)
}

func (s *CharacterContext) Iconst() IIconstContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IIconstContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IIconstContext)
}

func (s *CharacterContext) CLOSE_PAREN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCLOSE_PAREN, 0)
}

func (s *CharacterContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *CharacterContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *CharacterContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterCharacter(s)
	}
}

func (s *CharacterContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitCharacter(s)
	}
}

func (s *CharacterContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitCharacter(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Character() (localctx ICharacterContext) {
	localctx = NewCharacterContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1142, PostgreSQLParserRULE_character)
	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(8712)
		p.Character_c()
	}
	p.SetState(8717)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 530, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(8713)
			p.Match(PostgreSQLParserOPEN_PAREN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(8714)
			p.Iconst()
		}
		{
			p.SetState(8715)
			p.Match(PostgreSQLParserCLOSE_PAREN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	} else if p.HasError() { // JIM
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IConstcharacterContext is an interface to support dynamic dispatch.
type IConstcharacterContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Character_c() ICharacter_cContext
	OPEN_PAREN() antlr.TerminalNode
	Iconst() IIconstContext
	CLOSE_PAREN() antlr.TerminalNode

	// IsConstcharacterContext differentiates from other interfaces.
	IsConstcharacterContext()
}

type ConstcharacterContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyConstcharacterContext() *ConstcharacterContext {
	var p = new(ConstcharacterContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_constcharacter
	return p
}

func InitEmptyConstcharacterContext(p *ConstcharacterContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_constcharacter
}

func (*ConstcharacterContext) IsConstcharacterContext() {}

func NewConstcharacterContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ConstcharacterContext {
	var p = new(ConstcharacterContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_constcharacter

	return p
}

func (s *ConstcharacterContext) GetParser() antlr.Parser { return s.parser }

func (s *ConstcharacterContext) Character_c() ICharacter_cContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ICharacter_cContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ICharacter_cContext)
}

func (s *ConstcharacterContext) OPEN_PAREN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserOPEN_PAREN, 0)
}

func (s *ConstcharacterContext) Iconst() IIconstContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IIconstContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IIconstContext)
}

func (s *ConstcharacterContext) CLOSE_PAREN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCLOSE_PAREN, 0)
}

func (s *ConstcharacterContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *ConstcharacterContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *ConstcharacterContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterConstcharacter(s)
	}
}

func (s *ConstcharacterContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitConstcharacter(s)
	}
}

func (s *ConstcharacterContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitConstcharacter(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Constcharacter() (localctx IConstcharacterContext) {
	localctx = NewConstcharacterContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1144, PostgreSQLParserRULE_constcharacter)
	var _la int

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(8719)
		p.Character_c()
	}
	p.SetState(8724)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}
	_la = p.GetTokenStream().LA(1)

	if _la == PostgreSQLParserOPEN_PAREN {
		{
			p.SetState(8720)
			p.Match(PostgreSQLParserOPEN_PAREN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(8721)
			p.Iconst()
		}
		{
			p.SetState(8722)
			p.Match(PostgreSQLParserCLOSE_PAREN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// ICharacter_cContext is an interface to support dynamic dispatch.
type ICharacter_cContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Opt_varying() IOpt_varyingContext
	CHARACTER() antlr.TerminalNode
	CHAR_P() antlr.TerminalNode
	NCHAR() antlr.TerminalNode
	VARCHAR() antlr.TerminalNode
	NATIONAL() antlr.TerminalNode

	// IsCharacter_cContext differentiates from other interfaces.
	IsCharacter_cContext()
}

type Character_cContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyCharacter_cContext() *Character_cContext {
	var p = new(Character_cContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_character_c
	return p
}

func InitEmptyCharacter_cContext(p *Character_cContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_character_c
}

func (*Character_cContext) IsCharacter_cContext() {}

func NewCharacter_cContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Character_cContext {
	var p = new(Character_cContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_character_c

	return p
}

func (s *Character_cContext) GetParser() antlr.Parser { return s.parser }

func (s *Character_cContext) Opt_varying() IOpt_varyingContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOpt_varyingContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOpt_varyingContext)
}

func (s *Character_cContext) CHARACTER() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCHARACTER, 0)
}

func (s *Character_cContext) CHAR_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCHAR_P, 0)
}

func (s *Character_cContext) NCHAR() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserNCHAR, 0)
}

func (s *Character_cContext) VARCHAR() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserVARCHAR, 0)
}

func (s *Character_cContext) NATIONAL() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserNATIONAL, 0)
}

func (s *Character_cContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Character_cContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Character_cContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterCharacter_c(s)
	}
}

func (s *Character_cContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitCharacter_c(s)
	}
}

func (s *Character_cContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitCharacter_c(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Character_c() (localctx ICharacter_cContext) {
	localctx = NewCharacter_cContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1146, PostgreSQLParserRULE_character_c)
	var _la int

	p.SetState(8732)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetTokenStream().LA(1) {
	case PostgreSQLParserCHAR_P, PostgreSQLParserCHARACTER, PostgreSQLParserNCHAR:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(8726)
			_la = p.GetTokenStream().LA(1)

			if !((int64((_la-384)) & ^0x3f) == 0 && ((int64(1)<<(_la-384))&32771) != 0) {
				p.GetErrorHandler().RecoverInline(p)
			} else {
				p.GetErrorHandler().ReportMatch(p)
				p.Consume()
			}
		}
		{
			p.SetState(8727)
			p.Opt_varying()
		}

	case PostgreSQLParserVARCHAR:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(8728)
			p.Match(PostgreSQLParserVARCHAR)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case PostgreSQLParserNATIONAL:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(8729)
			p.Match(PostgreSQLParserNATIONAL)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(8730)
			_la = p.GetTokenStream().LA(1)

			if !(_la == PostgreSQLParserCHAR_P || _la == PostgreSQLParserCHARACTER) {
				p.GetErrorHandler().RecoverInline(p)
			} else {
				p.GetErrorHandler().ReportMatch(p)
				p.Consume()
			}
		}
		{
			p.SetState(8731)
			p.Opt_varying()
		}

	default:
		p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IOpt_varyingContext is an interface to support dynamic dispatch.
type IOpt_varyingContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	VARYING() antlr.TerminalNode

	// IsOpt_varyingContext differentiates from other interfaces.
	IsOpt_varyingContext()
}

type Opt_varyingContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyOpt_varyingContext() *Opt_varyingContext {
	var p = new(Opt_varyingContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opt_varying
	return p
}

func InitEmptyOpt_varyingContext(p *Opt_varyingContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opt_varying
}

func (*Opt_varyingContext) IsOpt_varyingContext() {}

func NewOpt_varyingContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_varyingContext {
	var p = new(Opt_varyingContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_opt_varying

	return p
}

func (s *Opt_varyingContext) GetParser() antlr.Parser { return s.parser }

func (s *Opt_varyingContext) VARYING() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserVARYING, 0)
}

func (s *Opt_varyingContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Opt_varyingContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Opt_varyingContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterOpt_varying(s)
	}
}

func (s *Opt_varyingContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitOpt_varying(s)
	}
}

func (s *Opt_varyingContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitOpt_varying(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Opt_varying() (localctx IOpt_varyingContext) {
	localctx = NewOpt_varyingContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1148, PostgreSQLParserRULE_opt_varying)
	p.SetState(8736)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 533, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(8734)
			p.Match(PostgreSQLParserVARYING)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)

	case antlr.ATNInvalidAltNumber:
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IConstdatetimeContext is an interface to support dynamic dispatch.
type IConstdatetimeContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Opt_timezone() IOpt_timezoneContext
	TIMESTAMP() antlr.TerminalNode
	TIME() antlr.TerminalNode
	OPEN_PAREN() antlr.TerminalNode
	Iconst() IIconstContext
	CLOSE_PAREN() antlr.TerminalNode

	// IsConstdatetimeContext differentiates from other interfaces.
	IsConstdatetimeContext()
}

type ConstdatetimeContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyConstdatetimeContext() *ConstdatetimeContext {
	var p = new(ConstdatetimeContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_constdatetime
	return p
}

func InitEmptyConstdatetimeContext(p *ConstdatetimeContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_constdatetime
}

func (*ConstdatetimeContext) IsConstdatetimeContext() {}

func NewConstdatetimeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ConstdatetimeContext {
	var p = new(ConstdatetimeContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_constdatetime

	return p
}

func (s *ConstdatetimeContext) GetParser() antlr.Parser { return s.parser }

func (s *ConstdatetimeContext) Opt_timezone() IOpt_timezoneContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOpt_timezoneContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOpt_timezoneContext)
}

func (s *ConstdatetimeContext) TIMESTAMP() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserTIMESTAMP, 0)
}

func (s *ConstdatetimeContext) TIME() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserTIME, 0)
}

func (s *ConstdatetimeContext) OPEN_PAREN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserOPEN_PAREN, 0)
}

func (s *ConstdatetimeContext) Iconst() IIconstContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IIconstContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IIconstContext)
}

func (s *ConstdatetimeContext) CLOSE_PAREN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCLOSE_PAREN, 0)
}

func (s *ConstdatetimeContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *ConstdatetimeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *ConstdatetimeContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterConstdatetime(s)
	}
}

func (s *ConstdatetimeContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitConstdatetime(s)
	}
}

func (s *ConstdatetimeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitConstdatetime(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Constdatetime() (localctx IConstdatetimeContext) {
	localctx = NewConstdatetimeContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1150, PostgreSQLParserRULE_constdatetime)
	var _la int

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(8738)
		_la = p.GetTokenStream().LA(1)

		if !(_la == PostgreSQLParserTIME || _la == PostgreSQLParserTIMESTAMP) {
			p.GetErrorHandler().RecoverInline(p)
		} else {
			p.GetErrorHandler().ReportMatch(p)
			p.Consume()
		}
	}
	p.SetState(8743)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 534, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(8739)
			p.Match(PostgreSQLParserOPEN_PAREN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(8740)
			p.Iconst()
		}
		{
			p.SetState(8741)
			p.Match(PostgreSQLParserCLOSE_PAREN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	} else if p.HasError() { // JIM
		goto errorExit
	}
	{
		p.SetState(8745)
		p.Opt_timezone()
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IConstintervalContext is an interface to support dynamic dispatch.
type IConstintervalContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	INTERVAL() antlr.TerminalNode

	// IsConstintervalContext differentiates from other interfaces.
	IsConstintervalContext()
}

type ConstintervalContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyConstintervalContext() *ConstintervalContext {
	var p = new(ConstintervalContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_constinterval
	return p
}

func InitEmptyConstintervalContext(p *ConstintervalContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_constinterval
}

func (*ConstintervalContext) IsConstintervalContext() {}

func NewConstintervalContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ConstintervalContext {
	var p = new(ConstintervalContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_constinterval

	return p
}

func (s *ConstintervalContext) GetParser() antlr.Parser { return s.parser }

func (s *ConstintervalContext) INTERVAL() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserINTERVAL, 0)
}

func (s *ConstintervalContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *ConstintervalContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *ConstintervalContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterConstinterval(s)
	}
}

func (s *ConstintervalContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitConstinterval(s)
	}
}

func (s *ConstintervalContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitConstinterval(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Constinterval() (localctx IConstintervalContext) {
	localctx = NewConstintervalContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1152, PostgreSQLParserRULE_constinterval)
	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(8747)
		p.Match(PostgreSQLParserINTERVAL)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IOpt_timezoneContext is an interface to support dynamic dispatch.
type IOpt_timezoneContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	WITH() antlr.TerminalNode
	TIME() antlr.TerminalNode
	ZONE() antlr.TerminalNode
	WITHOUT() antlr.TerminalNode

	// IsOpt_timezoneContext differentiates from other interfaces.
	IsOpt_timezoneContext()
}

type Opt_timezoneContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyOpt_timezoneContext() *Opt_timezoneContext {
	var p = new(Opt_timezoneContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opt_timezone
	return p
}

func InitEmptyOpt_timezoneContext(p *Opt_timezoneContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opt_timezone
}

func (*Opt_timezoneContext) IsOpt_timezoneContext() {}

func NewOpt_timezoneContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_timezoneContext {
	var p = new(Opt_timezoneContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_opt_timezone

	return p
}

func (s *Opt_timezoneContext) GetParser() antlr.Parser { return s.parser }

func (s *Opt_timezoneContext) WITH() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserWITH, 0)
}

func (s *Opt_timezoneContext) TIME() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserTIME, 0)
}

func (s *Opt_timezoneContext) ZONE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserZONE, 0)
}

func (s *Opt_timezoneContext) WITHOUT() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserWITHOUT, 0)
}

func (s *Opt_timezoneContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Opt_timezoneContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Opt_timezoneContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterOpt_timezone(s)
	}
}

func (s *Opt_timezoneContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitOpt_timezone(s)
	}
}

func (s *Opt_timezoneContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitOpt_timezone(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Opt_timezone() (localctx IOpt_timezoneContext) {
	localctx = NewOpt_timezoneContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1154, PostgreSQLParserRULE_opt_timezone)
	p.SetState(8756)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 535, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(8749)
			p.Match(PostgreSQLParserWITH)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(8750)
			p.Match(PostgreSQLParserTIME)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(8751)
			p.Match(PostgreSQLParserZONE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(8752)
			p.Match(PostgreSQLParserWITHOUT)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(8753)
			p.Match(PostgreSQLParserTIME)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(8754)
			p.Match(PostgreSQLParserZONE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 3:
		p.EnterOuterAlt(localctx, 3)

	case antlr.ATNInvalidAltNumber:
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IOpt_intervalContext is an interface to support dynamic dispatch.
type IOpt_intervalContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	YEAR_P() antlr.TerminalNode
	MONTH_P() antlr.TerminalNode
	DAY_P() antlr.TerminalNode
	HOUR_P() antlr.TerminalNode
	MINUTE_P() antlr.TerminalNode
	Interval_second() IInterval_secondContext
	TO() antlr.TerminalNode

	// IsOpt_intervalContext differentiates from other interfaces.
	IsOpt_intervalContext()
}

type Opt_intervalContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyOpt_intervalContext() *Opt_intervalContext {
	var p = new(Opt_intervalContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opt_interval
	return p
}

func InitEmptyOpt_intervalContext(p *Opt_intervalContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opt_interval
}

func (*Opt_intervalContext) IsOpt_intervalContext() {}

func NewOpt_intervalContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_intervalContext {
	var p = new(Opt_intervalContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_opt_interval

	return p
}

func (s *Opt_intervalContext) GetParser() antlr.Parser { return s.parser }

func (s *Opt_intervalContext) YEAR_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserYEAR_P, 0)
}

func (s *Opt_intervalContext) MONTH_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserMONTH_P, 0)
}

func (s *Opt_intervalContext) DAY_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserDAY_P, 0)
}

func (s *Opt_intervalContext) HOUR_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserHOUR_P, 0)
}

func (s *Opt_intervalContext) MINUTE_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserMINUTE_P, 0)
}

func (s *Opt_intervalContext) Interval_second() IInterval_secondContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IInterval_secondContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IInterval_secondContext)
}

func (s *Opt_intervalContext) TO() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserTO, 0)
}

func (s *Opt_intervalContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Opt_intervalContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Opt_intervalContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterOpt_interval(s)
	}
}

func (s *Opt_intervalContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitOpt_interval(s)
	}
}

func (s *Opt_intervalContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitOpt_interval(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Opt_interval() (localctx IOpt_intervalContext) {
	localctx = NewOpt_intervalContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1156, PostgreSQLParserRULE_opt_interval)
	p.SetState(8784)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 538, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(8758)
			p.Match(PostgreSQLParserYEAR_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(8759)
			p.Match(PostgreSQLParserMONTH_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 3:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(8760)
			p.Match(PostgreSQLParserDAY_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 4:
		p.EnterOuterAlt(localctx, 4)
		{
			p.SetState(8761)
			p.Match(PostgreSQLParserHOUR_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 5:
		p.EnterOuterAlt(localctx, 5)
		{
			p.SetState(8762)
			p.Match(PostgreSQLParserMINUTE_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 6:
		p.EnterOuterAlt(localctx, 6)
		{
			p.SetState(8763)
			p.Interval_second()
		}

	case 7:
		p.EnterOuterAlt(localctx, 7)
		{
			p.SetState(8764)
			p.Match(PostgreSQLParserYEAR_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(8765)
			p.Match(PostgreSQLParserTO)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(8766)
			p.Match(PostgreSQLParserMONTH_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 8:
		p.EnterOuterAlt(localctx, 8)
		{
			p.SetState(8767)
			p.Match(PostgreSQLParserDAY_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(8768)
			p.Match(PostgreSQLParserTO)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		p.SetState(8772)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}

		switch p.GetTokenStream().LA(1) {
		case PostgreSQLParserHOUR_P:
			{
				p.SetState(8769)
				p.Match(PostgreSQLParserHOUR_P)
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}

		case PostgreSQLParserMINUTE_P:
			{
				p.SetState(8770)
				p.Match(PostgreSQLParserMINUTE_P)
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}

		case PostgreSQLParserSECOND_P:
			{
				p.SetState(8771)
				p.Interval_second()
			}

		default:
			p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
			goto errorExit
		}

	case 9:
		p.EnterOuterAlt(localctx, 9)
		{
			p.SetState(8774)
			p.Match(PostgreSQLParserHOUR_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(8775)
			p.Match(PostgreSQLParserTO)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		p.SetState(8778)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}

		switch p.GetTokenStream().LA(1) {
		case PostgreSQLParserMINUTE_P:
			{
				p.SetState(8776)
				p.Match(PostgreSQLParserMINUTE_P)
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}

		case PostgreSQLParserSECOND_P:
			{
				p.SetState(8777)
				p.Interval_second()
			}

		default:
			p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
			goto errorExit
		}

	case 10:
		p.EnterOuterAlt(localctx, 10)
		{
			p.SetState(8780)
			p.Match(PostgreSQLParserMINUTE_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(8781)
			p.Match(PostgreSQLParserTO)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(8782)
			p.Interval_second()
		}

	case 11:
		p.EnterOuterAlt(localctx, 11)

	case antlr.ATNInvalidAltNumber:
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IInterval_secondContext is an interface to support dynamic dispatch.
type IInterval_secondContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	SECOND_P() antlr.TerminalNode
	OPEN_PAREN() antlr.TerminalNode
	Iconst() IIconstContext
	CLOSE_PAREN() antlr.TerminalNode

	// IsInterval_secondContext differentiates from other interfaces.
	IsInterval_secondContext()
}

type Interval_secondContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyInterval_secondContext() *Interval_secondContext {
	var p = new(Interval_secondContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_interval_second
	return p
}

func InitEmptyInterval_secondContext(p *Interval_secondContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_interval_second
}

func (*Interval_secondContext) IsInterval_secondContext() {}

func NewInterval_secondContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Interval_secondContext {
	var p = new(Interval_secondContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_interval_second

	return p
}

func (s *Interval_secondContext) GetParser() antlr.Parser { return s.parser }

func (s *Interval_secondContext) SECOND_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserSECOND_P, 0)
}

func (s *Interval_secondContext) OPEN_PAREN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserOPEN_PAREN, 0)
}

func (s *Interval_secondContext) Iconst() IIconstContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IIconstContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IIconstContext)
}

func (s *Interval_secondContext) CLOSE_PAREN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCLOSE_PAREN, 0)
}

func (s *Interval_secondContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Interval_secondContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Interval_secondContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterInterval_second(s)
	}
}

func (s *Interval_secondContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitInterval_second(s)
	}
}

func (s *Interval_secondContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitInterval_second(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Interval_second() (localctx IInterval_secondContext) {
	localctx = NewInterval_secondContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1158, PostgreSQLParserRULE_interval_second)
	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(8786)
		p.Match(PostgreSQLParserSECOND_P)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	p.SetState(8791)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 539, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(8787)
			p.Match(PostgreSQLParserOPEN_PAREN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(8788)
			p.Iconst()
		}
		{
			p.SetState(8789)
			p.Match(PostgreSQLParserCLOSE_PAREN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	} else if p.HasError() { // JIM
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IOpt_escapeContext is an interface to support dynamic dispatch.
type IOpt_escapeContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	ESCAPE() antlr.TerminalNode
	A_expr() IA_exprContext

	// IsOpt_escapeContext differentiates from other interfaces.
	IsOpt_escapeContext()
}

type Opt_escapeContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyOpt_escapeContext() *Opt_escapeContext {
	var p = new(Opt_escapeContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opt_escape
	return p
}

func InitEmptyOpt_escapeContext(p *Opt_escapeContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opt_escape
}

func (*Opt_escapeContext) IsOpt_escapeContext() {}

func NewOpt_escapeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_escapeContext {
	var p = new(Opt_escapeContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_opt_escape

	return p
}

func (s *Opt_escapeContext) GetParser() antlr.Parser { return s.parser }

func (s *Opt_escapeContext) ESCAPE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserESCAPE, 0)
}

func (s *Opt_escapeContext) A_expr() IA_exprContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IA_exprContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IA_exprContext)
}

func (s *Opt_escapeContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Opt_escapeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Opt_escapeContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterOpt_escape(s)
	}
}

func (s *Opt_escapeContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitOpt_escape(s)
	}
}

func (s *Opt_escapeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitOpt_escape(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Opt_escape() (localctx IOpt_escapeContext) {
	localctx = NewOpt_escapeContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1160, PostgreSQLParserRULE_opt_escape)
	p.SetState(8796)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 540, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(8793)
			p.Match(PostgreSQLParserESCAPE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(8794)
			p.A_expr()
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)

	case antlr.ATNInvalidAltNumber:
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IA_exprContext is an interface to support dynamic dispatch.
type IA_exprContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	A_expr_qual() IA_expr_qualContext

	// IsA_exprContext differentiates from other interfaces.
	IsA_exprContext()
}

type A_exprContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyA_exprContext() *A_exprContext {
	var p = new(A_exprContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_a_expr
	return p
}

func InitEmptyA_exprContext(p *A_exprContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_a_expr
}

func (*A_exprContext) IsA_exprContext() {}

func NewA_exprContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *A_exprContext {
	var p = new(A_exprContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_a_expr

	return p
}

func (s *A_exprContext) GetParser() antlr.Parser { return s.parser }

func (s *A_exprContext) A_expr_qual() IA_expr_qualContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IA_expr_qualContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IA_expr_qualContext)
}

func (s *A_exprContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *A_exprContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *A_exprContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterA_expr(s)
	}
}

func (s *A_exprContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitA_expr(s)
	}
}

func (s *A_exprContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitA_expr(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) A_expr() (localctx IA_exprContext) {
	localctx = NewA_exprContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1162, PostgreSQLParserRULE_a_expr)
	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(8798)
		p.A_expr_qual()
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IA_expr_qualContext is an interface to support dynamic dispatch.
type IA_expr_qualContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	A_expr_lessless() IA_expr_lesslessContext
	Qual_op() IQual_opContext

	// IsA_expr_qualContext differentiates from other interfaces.
	IsA_expr_qualContext()
}

type A_expr_qualContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyA_expr_qualContext() *A_expr_qualContext {
	var p = new(A_expr_qualContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_a_expr_qual
	return p
}

func InitEmptyA_expr_qualContext(p *A_expr_qualContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_a_expr_qual
}

func (*A_expr_qualContext) IsA_expr_qualContext() {}

func NewA_expr_qualContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *A_expr_qualContext {
	var p = new(A_expr_qualContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_a_expr_qual

	return p
}

func (s *A_expr_qualContext) GetParser() antlr.Parser { return s.parser }

func (s *A_expr_qualContext) A_expr_lessless() IA_expr_lesslessContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IA_expr_lesslessContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IA_expr_lesslessContext)
}

func (s *A_expr_qualContext) Qual_op() IQual_opContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IQual_opContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IQual_opContext)
}

func (s *A_expr_qualContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *A_expr_qualContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *A_expr_qualContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterA_expr_qual(s)
	}
}

func (s *A_expr_qualContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitA_expr_qual(s)
	}
}

func (s *A_expr_qualContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitA_expr_qual(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) A_expr_qual() (localctx IA_expr_qualContext) {
	localctx = NewA_expr_qualContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1164, PostgreSQLParserRULE_a_expr_qual)
	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(8800)
		p.A_expr_lessless()
	}
	p.SetState(8802)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 541, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(8801)
			p.Qual_op()
		}

	} else if p.HasError() { // JIM
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IA_expr_lesslessContext is an interface to support dynamic dispatch.
type IA_expr_lesslessContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	AllA_expr_or() []IA_expr_orContext
	A_expr_or(i int) IA_expr_orContext
	AllLESS_LESS() []antlr.TerminalNode
	LESS_LESS(i int) antlr.TerminalNode
	AllGREATER_GREATER() []antlr.TerminalNode
	GREATER_GREATER(i int) antlr.TerminalNode

	// IsA_expr_lesslessContext differentiates from other interfaces.
	IsA_expr_lesslessContext()
}

type A_expr_lesslessContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyA_expr_lesslessContext() *A_expr_lesslessContext {
	var p = new(A_expr_lesslessContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_a_expr_lessless
	return p
}

func InitEmptyA_expr_lesslessContext(p *A_expr_lesslessContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_a_expr_lessless
}

func (*A_expr_lesslessContext) IsA_expr_lesslessContext() {}

func NewA_expr_lesslessContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *A_expr_lesslessContext {
	var p = new(A_expr_lesslessContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_a_expr_lessless

	return p
}

func (s *A_expr_lesslessContext) GetParser() antlr.Parser { return s.parser }

func (s *A_expr_lesslessContext) AllA_expr_or() []IA_expr_orContext {
	children := s.GetChildren()
	len := 0
	for _, ctx := range children {
		if _, ok := ctx.(IA_expr_orContext); ok {
			len++
		}
	}

	tst := make([]IA_expr_orContext, len)
	i := 0
	for _, ctx := range children {
		if t, ok := ctx.(IA_expr_orContext); ok {
			tst[i] = t.(IA_expr_orContext)
			i++
		}
	}

	return tst
}

func (s *A_expr_lesslessContext) A_expr_or(i int) IA_expr_orContext {
	var t antlr.RuleContext
	j := 0
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IA_expr_orContext); ok {
			if j == i {
				t = ctx.(antlr.RuleContext)
				break
			}
			j++
		}
	}

	if t == nil {
		return nil
	}

	return t.(IA_expr_orContext)
}

func (s *A_expr_lesslessContext) AllLESS_LESS() []antlr.TerminalNode {
	return s.GetTokens(PostgreSQLParserLESS_LESS)
}

func (s *A_expr_lesslessContext) LESS_LESS(i int) antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserLESS_LESS, i)
}

func (s *A_expr_lesslessContext) AllGREATER_GREATER() []antlr.TerminalNode {
	return s.GetTokens(PostgreSQLParserGREATER_GREATER)
}

func (s *A_expr_lesslessContext) GREATER_GREATER(i int) antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserGREATER_GREATER, i)
}

func (s *A_expr_lesslessContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *A_expr_lesslessContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *A_expr_lesslessContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterA_expr_lessless(s)
	}
}

func (s *A_expr_lesslessContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitA_expr_lessless(s)
	}
}

func (s *A_expr_lesslessContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitA_expr_lessless(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) A_expr_lessless() (localctx IA_expr_lesslessContext) {
	localctx = NewA_expr_lesslessContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1166, PostgreSQLParserRULE_a_expr_lessless)
	var _la int

	var _alt int

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(8804)
		p.A_expr_or()
	}
	p.SetState(8809)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}
	_alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 542, p.GetParserRuleContext())
	if p.HasError() {
		goto errorExit
	}
	for _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
		if _alt == 1 {
			{
				p.SetState(8805)
				_la = p.GetTokenStream().LA(1)

				if !(_la == PostgreSQLParserLESS_LESS || _la == PostgreSQLParserGREATER_GREATER) {
					p.GetErrorHandler().RecoverInline(p)
				} else {
					p.GetErrorHandler().ReportMatch(p)
					p.Consume()
				}
			}
			{
				p.SetState(8806)
				p.A_expr_or()
			}

		}
		p.SetState(8811)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}
		_alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 542, p.GetParserRuleContext())
		if p.HasError() {
			goto errorExit
		}
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IA_expr_orContext is an interface to support dynamic dispatch.
type IA_expr_orContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	AllA_expr_and() []IA_expr_andContext
	A_expr_and(i int) IA_expr_andContext
	AllOR() []antlr.TerminalNode
	OR(i int) antlr.TerminalNode

	// IsA_expr_orContext differentiates from other interfaces.
	IsA_expr_orContext()
}

type A_expr_orContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyA_expr_orContext() *A_expr_orContext {
	var p = new(A_expr_orContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_a_expr_or
	return p
}

func InitEmptyA_expr_orContext(p *A_expr_orContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_a_expr_or
}

func (*A_expr_orContext) IsA_expr_orContext() {}

func NewA_expr_orContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *A_expr_orContext {
	var p = new(A_expr_orContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_a_expr_or

	return p
}

func (s *A_expr_orContext) GetParser() antlr.Parser { return s.parser }

func (s *A_expr_orContext) AllA_expr_and() []IA_expr_andContext {
	children := s.GetChildren()
	len := 0
	for _, ctx := range children {
		if _, ok := ctx.(IA_expr_andContext); ok {
			len++
		}
	}

	tst := make([]IA_expr_andContext, len)
	i := 0
	for _, ctx := range children {
		if t, ok := ctx.(IA_expr_andContext); ok {
			tst[i] = t.(IA_expr_andContext)
			i++
		}
	}

	return tst
}

func (s *A_expr_orContext) A_expr_and(i int) IA_expr_andContext {
	var t antlr.RuleContext
	j := 0
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IA_expr_andContext); ok {
			if j == i {
				t = ctx.(antlr.RuleContext)
				break
			}
			j++
		}
	}

	if t == nil {
		return nil
	}

	return t.(IA_expr_andContext)
}

func (s *A_expr_orContext) AllOR() []antlr.TerminalNode {
	return s.GetTokens(PostgreSQLParserOR)
}

func (s *A_expr_orContext) OR(i int) antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserOR, i)
}

func (s *A_expr_orContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *A_expr_orContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *A_expr_orContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterA_expr_or(s)
	}
}

func (s *A_expr_orContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitA_expr_or(s)
	}
}

func (s *A_expr_orContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitA_expr_or(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) A_expr_or() (localctx IA_expr_orContext) {
	localctx = NewA_expr_orContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1168, PostgreSQLParserRULE_a_expr_or)
	var _alt int

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(8812)
		p.A_expr_and()
	}
	p.SetState(8817)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}
	_alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 543, p.GetParserRuleContext())
	if p.HasError() {
		goto errorExit
	}
	for _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
		if _alt == 1 {
			{
				p.SetState(8813)
				p.Match(PostgreSQLParserOR)
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}
			{
				p.SetState(8814)
				p.A_expr_and()
			}

		}
		p.SetState(8819)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}
		_alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 543, p.GetParserRuleContext())
		if p.HasError() {
			goto errorExit
		}
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IA_expr_andContext is an interface to support dynamic dispatch.
type IA_expr_andContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	AllA_expr_between() []IA_expr_betweenContext
	A_expr_between(i int) IA_expr_betweenContext
	AllAND() []antlr.TerminalNode
	AND(i int) antlr.TerminalNode

	// IsA_expr_andContext differentiates from other interfaces.
	IsA_expr_andContext()
}

type A_expr_andContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyA_expr_andContext() *A_expr_andContext {
	var p = new(A_expr_andContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_a_expr_and
	return p
}

func InitEmptyA_expr_andContext(p *A_expr_andContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_a_expr_and
}

func (*A_expr_andContext) IsA_expr_andContext() {}

func NewA_expr_andContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *A_expr_andContext {
	var p = new(A_expr_andContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_a_expr_and

	return p
}

func (s *A_expr_andContext) GetParser() antlr.Parser { return s.parser }

func (s *A_expr_andContext) AllA_expr_between() []IA_expr_betweenContext {
	children := s.GetChildren()
	len := 0
	for _, ctx := range children {
		if _, ok := ctx.(IA_expr_betweenContext); ok {
			len++
		}
	}

	tst := make([]IA_expr_betweenContext, len)
	i := 0
	for _, ctx := range children {
		if t, ok := ctx.(IA_expr_betweenContext); ok {
			tst[i] = t.(IA_expr_betweenContext)
			i++
		}
	}

	return tst
}

func (s *A_expr_andContext) A_expr_between(i int) IA_expr_betweenContext {
	var t antlr.RuleContext
	j := 0
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IA_expr_betweenContext); ok {
			if j == i {
				t = ctx.(antlr.RuleContext)
				break
			}
			j++
		}
	}

	if t == nil {
		return nil
	}

	return t.(IA_expr_betweenContext)
}

func (s *A_expr_andContext) AllAND() []antlr.TerminalNode {
	return s.GetTokens(PostgreSQLParserAND)
}

func (s *A_expr_andContext) AND(i int) antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserAND, i)
}

func (s *A_expr_andContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *A_expr_andContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *A_expr_andContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterA_expr_and(s)
	}
}

func (s *A_expr_andContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitA_expr_and(s)
	}
}

func (s *A_expr_andContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitA_expr_and(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) A_expr_and() (localctx IA_expr_andContext) {
	localctx = NewA_expr_andContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1170, PostgreSQLParserRULE_a_expr_and)
	var _alt int

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(8820)
		p.A_expr_between()
	}
	p.SetState(8825)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}
	_alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 544, p.GetParserRuleContext())
	if p.HasError() {
		goto errorExit
	}
	for _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
		if _alt == 1 {
			{
				p.SetState(8821)
				p.Match(PostgreSQLParserAND)
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}
			{
				p.SetState(8822)
				p.A_expr_between()
			}

		}
		p.SetState(8827)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}
		_alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 544, p.GetParserRuleContext())
		if p.HasError() {
			goto errorExit
		}
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IA_expr_betweenContext is an interface to support dynamic dispatch.
type IA_expr_betweenContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	AllA_expr_in() []IA_expr_inContext
	A_expr_in(i int) IA_expr_inContext
	BETWEEN() antlr.TerminalNode
	AND() antlr.TerminalNode
	NOT() antlr.TerminalNode
	SYMMETRIC() antlr.TerminalNode

	// IsA_expr_betweenContext differentiates from other interfaces.
	IsA_expr_betweenContext()
}

type A_expr_betweenContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyA_expr_betweenContext() *A_expr_betweenContext {
	var p = new(A_expr_betweenContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_a_expr_between
	return p
}

func InitEmptyA_expr_betweenContext(p *A_expr_betweenContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_a_expr_between
}

func (*A_expr_betweenContext) IsA_expr_betweenContext() {}

func NewA_expr_betweenContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *A_expr_betweenContext {
	var p = new(A_expr_betweenContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_a_expr_between

	return p
}

func (s *A_expr_betweenContext) GetParser() antlr.Parser { return s.parser }

func (s *A_expr_betweenContext) AllA_expr_in() []IA_expr_inContext {
	children := s.GetChildren()
	len := 0
	for _, ctx := range children {
		if _, ok := ctx.(IA_expr_inContext); ok {
			len++
		}
	}

	tst := make([]IA_expr_inContext, len)
	i := 0
	for _, ctx := range children {
		if t, ok := ctx.(IA_expr_inContext); ok {
			tst[i] = t.(IA_expr_inContext)
			i++
		}
	}

	return tst
}

func (s *A_expr_betweenContext) A_expr_in(i int) IA_expr_inContext {
	var t antlr.RuleContext
	j := 0
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IA_expr_inContext); ok {
			if j == i {
				t = ctx.(antlr.RuleContext)
				break
			}
			j++
		}
	}

	if t == nil {
		return nil
	}

	return t.(IA_expr_inContext)
}

func (s *A_expr_betweenContext) BETWEEN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserBETWEEN, 0)
}

func (s *A_expr_betweenContext) AND() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserAND, 0)
}

func (s *A_expr_betweenContext) NOT() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserNOT, 0)
}

func (s *A_expr_betweenContext) SYMMETRIC() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserSYMMETRIC, 0)
}

func (s *A_expr_betweenContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *A_expr_betweenContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *A_expr_betweenContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterA_expr_between(s)
	}
}

func (s *A_expr_betweenContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitA_expr_between(s)
	}
}

func (s *A_expr_betweenContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitA_expr_between(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) A_expr_between() (localctx IA_expr_betweenContext) {
	localctx = NewA_expr_betweenContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1172, PostgreSQLParserRULE_a_expr_between)
	var _la int

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(8828)
		p.A_expr_in()
	}
	p.SetState(8840)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 547, p.GetParserRuleContext()) == 1 {
		p.SetState(8830)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}
		_la = p.GetTokenStream().LA(1)

		if _la == PostgreSQLParserNOT {
			{
				p.SetState(8829)
				p.Match(PostgreSQLParserNOT)
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}

		}
		{
			p.SetState(8832)
			p.Match(PostgreSQLParserBETWEEN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		p.SetState(8834)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}
		_la = p.GetTokenStream().LA(1)

		if _la == PostgreSQLParserSYMMETRIC {
			{
				p.SetState(8833)
				p.Match(PostgreSQLParserSYMMETRIC)
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}

		}
		{
			p.SetState(8836)
			p.A_expr_in()
		}
		{
			p.SetState(8837)
			p.Match(PostgreSQLParserAND)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(8838)
			p.A_expr_in()
		}

	} else if p.HasError() { // JIM
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IA_expr_inContext is an interface to support dynamic dispatch.
type IA_expr_inContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	A_expr_unary_not() IA_expr_unary_notContext
	IN_P() antlr.TerminalNode
	In_expr() IIn_exprContext
	NOT() antlr.TerminalNode

	// IsA_expr_inContext differentiates from other interfaces.
	IsA_expr_inContext()
}

type A_expr_inContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyA_expr_inContext() *A_expr_inContext {
	var p = new(A_expr_inContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_a_expr_in
	return p
}

func InitEmptyA_expr_inContext(p *A_expr_inContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_a_expr_in
}

func (*A_expr_inContext) IsA_expr_inContext() {}

func NewA_expr_inContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *A_expr_inContext {
	var p = new(A_expr_inContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_a_expr_in

	return p
}

func (s *A_expr_inContext) GetParser() antlr.Parser { return s.parser }

func (s *A_expr_inContext) A_expr_unary_not() IA_expr_unary_notContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IA_expr_unary_notContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IA_expr_unary_notContext)
}

func (s *A_expr_inContext) IN_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserIN_P, 0)
}

func (s *A_expr_inContext) In_expr() IIn_exprContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IIn_exprContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IIn_exprContext)
}

func (s *A_expr_inContext) NOT() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserNOT, 0)
}

func (s *A_expr_inContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *A_expr_inContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *A_expr_inContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterA_expr_in(s)
	}
}

func (s *A_expr_inContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitA_expr_in(s)
	}
}

func (s *A_expr_inContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitA_expr_in(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) A_expr_in() (localctx IA_expr_inContext) {
	localctx = NewA_expr_inContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1174, PostgreSQLParserRULE_a_expr_in)
	var _la int

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(8842)
		p.A_expr_unary_not()
	}
	p.SetState(8848)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 549, p.GetParserRuleContext()) == 1 {
		p.SetState(8844)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}
		_la = p.GetTokenStream().LA(1)

		if _la == PostgreSQLParserNOT {
			{
				p.SetState(8843)
				p.Match(PostgreSQLParserNOT)
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}

		}
		{
			p.SetState(8846)
			p.Match(PostgreSQLParserIN_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(8847)
			p.In_expr()
		}

	} else if p.HasError() { // JIM
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IA_expr_unary_notContext is an interface to support dynamic dispatch.
type IA_expr_unary_notContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	A_expr_isnull() IA_expr_isnullContext
	NOT() antlr.TerminalNode

	// IsA_expr_unary_notContext differentiates from other interfaces.
	IsA_expr_unary_notContext()
}

type A_expr_unary_notContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyA_expr_unary_notContext() *A_expr_unary_notContext {
	var p = new(A_expr_unary_notContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_a_expr_unary_not
	return p
}

func InitEmptyA_expr_unary_notContext(p *A_expr_unary_notContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_a_expr_unary_not
}

func (*A_expr_unary_notContext) IsA_expr_unary_notContext() {}

func NewA_expr_unary_notContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *A_expr_unary_notContext {
	var p = new(A_expr_unary_notContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_a_expr_unary_not

	return p
}

func (s *A_expr_unary_notContext) GetParser() antlr.Parser { return s.parser }

func (s *A_expr_unary_notContext) A_expr_isnull() IA_expr_isnullContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IA_expr_isnullContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IA_expr_isnullContext)
}

func (s *A_expr_unary_notContext) NOT() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserNOT, 0)
}

func (s *A_expr_unary_notContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *A_expr_unary_notContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *A_expr_unary_notContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterA_expr_unary_not(s)
	}
}

func (s *A_expr_unary_notContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitA_expr_unary_not(s)
	}
}

func (s *A_expr_unary_notContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitA_expr_unary_not(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) A_expr_unary_not() (localctx IA_expr_unary_notContext) {
	localctx = NewA_expr_unary_notContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1176, PostgreSQLParserRULE_a_expr_unary_not)
	var _la int

	p.EnterOuterAlt(localctx, 1)
	p.SetState(8851)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}
	_la = p.GetTokenStream().LA(1)

	if _la == PostgreSQLParserNOT {
		{
			p.SetState(8850)
			p.Match(PostgreSQLParserNOT)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	}
	{
		p.SetState(8853)
		p.A_expr_isnull()
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IA_expr_isnullContext is an interface to support dynamic dispatch.
type IA_expr_isnullContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	A_expr_is_not() IA_expr_is_notContext
	ISNULL() antlr.TerminalNode
	NOTNULL() antlr.TerminalNode

	// IsA_expr_isnullContext differentiates from other interfaces.
	IsA_expr_isnullContext()
}

type A_expr_isnullContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyA_expr_isnullContext() *A_expr_isnullContext {
	var p = new(A_expr_isnullContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_a_expr_isnull
	return p
}

func InitEmptyA_expr_isnullContext(p *A_expr_isnullContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_a_expr_isnull
}

func (*A_expr_isnullContext) IsA_expr_isnullContext() {}

func NewA_expr_isnullContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *A_expr_isnullContext {
	var p = new(A_expr_isnullContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_a_expr_isnull

	return p
}

func (s *A_expr_isnullContext) GetParser() antlr.Parser { return s.parser }

func (s *A_expr_isnullContext) A_expr_is_not() IA_expr_is_notContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IA_expr_is_notContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IA_expr_is_notContext)
}

func (s *A_expr_isnullContext) ISNULL() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserISNULL, 0)
}

func (s *A_expr_isnullContext) NOTNULL() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserNOTNULL, 0)
}

func (s *A_expr_isnullContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *A_expr_isnullContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *A_expr_isnullContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterA_expr_isnull(s)
	}
}

func (s *A_expr_isnullContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitA_expr_isnull(s)
	}
}

func (s *A_expr_isnullContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitA_expr_isnull(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) A_expr_isnull() (localctx IA_expr_isnullContext) {
	localctx = NewA_expr_isnullContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1178, PostgreSQLParserRULE_a_expr_isnull)
	var _la int

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(8855)
		p.A_expr_is_not()
	}
	p.SetState(8857)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 551, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(8856)
			_la = p.GetTokenStream().LA(1)

			if !(_la == PostgreSQLParserISNULL || _la == PostgreSQLParserNOTNULL) {
				p.GetErrorHandler().RecoverInline(p)
			} else {
				p.GetErrorHandler().ReportMatch(p)
				p.Consume()
			}
		}

	} else if p.HasError() { // JIM
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IA_expr_is_notContext is an interface to support dynamic dispatch.
type IA_expr_is_notContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	A_expr_compare() IA_expr_compareContext
	IS() antlr.TerminalNode
	NULL_P() antlr.TerminalNode
	TRUE_P() antlr.TerminalNode
	FALSE_P() antlr.TerminalNode
	UNKNOWN() antlr.TerminalNode
	DISTINCT() antlr.TerminalNode
	FROM() antlr.TerminalNode
	A_expr() IA_exprContext
	OF() antlr.TerminalNode
	OPEN_PAREN() antlr.TerminalNode
	Type_list() IType_listContext
	CLOSE_PAREN() antlr.TerminalNode
	DOCUMENT_P() antlr.TerminalNode
	NORMALIZED() antlr.TerminalNode
	NOT() antlr.TerminalNode
	Unicode_normal_form() IUnicode_normal_formContext

	// IsA_expr_is_notContext differentiates from other interfaces.
	IsA_expr_is_notContext()
}

type A_expr_is_notContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyA_expr_is_notContext() *A_expr_is_notContext {
	var p = new(A_expr_is_notContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_a_expr_is_not
	return p
}

func InitEmptyA_expr_is_notContext(p *A_expr_is_notContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_a_expr_is_not
}

func (*A_expr_is_notContext) IsA_expr_is_notContext() {}

func NewA_expr_is_notContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *A_expr_is_notContext {
	var p = new(A_expr_is_notContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_a_expr_is_not

	return p
}

func (s *A_expr_is_notContext) GetParser() antlr.Parser { return s.parser }

func (s *A_expr_is_notContext) A_expr_compare() IA_expr_compareContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IA_expr_compareContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IA_expr_compareContext)
}

func (s *A_expr_is_notContext) IS() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserIS, 0)
}

func (s *A_expr_is_notContext) NULL_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserNULL_P, 0)
}

func (s *A_expr_is_notContext) TRUE_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserTRUE_P, 0)
}

func (s *A_expr_is_notContext) FALSE_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserFALSE_P, 0)
}

func (s *A_expr_is_notContext) UNKNOWN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserUNKNOWN, 0)
}

func (s *A_expr_is_notContext) DISTINCT() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserDISTINCT, 0)
}

func (s *A_expr_is_notContext) FROM() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserFROM, 0)
}

func (s *A_expr_is_notContext) A_expr() IA_exprContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IA_exprContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IA_exprContext)
}

func (s *A_expr_is_notContext) OF() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserOF, 0)
}

func (s *A_expr_is_notContext) OPEN_PAREN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserOPEN_PAREN, 0)
}

func (s *A_expr_is_notContext) Type_list() IType_listContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IType_listContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IType_listContext)
}

func (s *A_expr_is_notContext) CLOSE_PAREN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCLOSE_PAREN, 0)
}

func (s *A_expr_is_notContext) DOCUMENT_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserDOCUMENT_P, 0)
}

func (s *A_expr_is_notContext) NORMALIZED() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserNORMALIZED, 0)
}

func (s *A_expr_is_notContext) NOT() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserNOT, 0)
}

func (s *A_expr_is_notContext) Unicode_normal_form() IUnicode_normal_formContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IUnicode_normal_formContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IUnicode_normal_formContext)
}

func (s *A_expr_is_notContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *A_expr_is_notContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *A_expr_is_notContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterA_expr_is_not(s)
	}
}

func (s *A_expr_is_notContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitA_expr_is_not(s)
	}
}

func (s *A_expr_is_notContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitA_expr_is_not(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) A_expr_is_not() (localctx IA_expr_is_notContext) {
	localctx = NewA_expr_is_notContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1180, PostgreSQLParserRULE_a_expr_is_not)
	var _la int

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(8859)
		p.A_expr_compare()
	}
	p.SetState(8883)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 555, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(8860)
			p.Match(PostgreSQLParserIS)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		p.SetState(8862)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}
		_la = p.GetTokenStream().LA(1)

		if _la == PostgreSQLParserNOT {
			{
				p.SetState(8861)
				p.Match(PostgreSQLParserNOT)
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}

		}
		p.SetState(8881)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}

		switch p.GetTokenStream().LA(1) {
		case PostgreSQLParserNULL_P:
			{
				p.SetState(8864)
				p.Match(PostgreSQLParserNULL_P)
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}

		case PostgreSQLParserTRUE_P:
			{
				p.SetState(8865)
				p.Match(PostgreSQLParserTRUE_P)
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}

		case PostgreSQLParserFALSE_P:
			{
				p.SetState(8866)
				p.Match(PostgreSQLParserFALSE_P)
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}

		case PostgreSQLParserUNKNOWN:
			{
				p.SetState(8867)
				p.Match(PostgreSQLParserUNKNOWN)
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}

		case PostgreSQLParserDISTINCT:
			{
				p.SetState(8868)
				p.Match(PostgreSQLParserDISTINCT)
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}
			{
				p.SetState(8869)
				p.Match(PostgreSQLParserFROM)
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}
			{
				p.SetState(8870)
				p.A_expr()
			}

		case PostgreSQLParserOF:
			{
				p.SetState(8871)
				p.Match(PostgreSQLParserOF)
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}
			{
				p.SetState(8872)
				p.Match(PostgreSQLParserOPEN_PAREN)
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}
			{
				p.SetState(8873)
				p.Type_list()
			}
			{
				p.SetState(8874)
				p.Match(PostgreSQLParserCLOSE_PAREN)
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}

		case PostgreSQLParserDOCUMENT_P:
			{
				p.SetState(8876)
				p.Match(PostgreSQLParserDOCUMENT_P)
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}

		case PostgreSQLParserNORMALIZED, PostgreSQLParserNFC, PostgreSQLParserNFD, PostgreSQLParserNFKC, PostgreSQLParserNFKD:
			p.SetState(8878)
			p.GetErrorHandler().Sync(p)
			if p.HasError() {
				goto errorExit
			}
			_la = p.GetTokenStream().LA(1)

			if (int64((_la-483)) & ^0x3f) == 0 && ((int64(1)<<(_la-483))&15) != 0 {
				{
					p.SetState(8877)
					p.Unicode_normal_form()
				}

			}
			{
				p.SetState(8880)
				p.Match(PostgreSQLParserNORMALIZED)
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}

		default:
			p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
			goto errorExit
		}

	} else if p.HasError() { // JIM
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IA_expr_compareContext is an interface to support dynamic dispatch.
type IA_expr_compareContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	AllA_expr_like() []IA_expr_likeContext
	A_expr_like(i int) IA_expr_likeContext
	Subquery_Op() ISubquery_OpContext
	Sub_type() ISub_typeContext
	LT() antlr.TerminalNode
	GT() antlr.TerminalNode
	EQUAL() antlr.TerminalNode
	LESS_EQUALS() antlr.TerminalNode
	GREATER_EQUALS() antlr.TerminalNode
	NOT_EQUALS() antlr.TerminalNode
	Select_with_parens() ISelect_with_parensContext
	OPEN_PAREN() antlr.TerminalNode
	A_expr() IA_exprContext
	CLOSE_PAREN() antlr.TerminalNode

	// IsA_expr_compareContext differentiates from other interfaces.
	IsA_expr_compareContext()
}

type A_expr_compareContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyA_expr_compareContext() *A_expr_compareContext {
	var p = new(A_expr_compareContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_a_expr_compare
	return p
}

func InitEmptyA_expr_compareContext(p *A_expr_compareContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_a_expr_compare
}

func (*A_expr_compareContext) IsA_expr_compareContext() {}

func NewA_expr_compareContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *A_expr_compareContext {
	var p = new(A_expr_compareContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_a_expr_compare

	return p
}

func (s *A_expr_compareContext) GetParser() antlr.Parser { return s.parser }

func (s *A_expr_compareContext) AllA_expr_like() []IA_expr_likeContext {
	children := s.GetChildren()
	len := 0
	for _, ctx := range children {
		if _, ok := ctx.(IA_expr_likeContext); ok {
			len++
		}
	}

	tst := make([]IA_expr_likeContext, len)
	i := 0
	for _, ctx := range children {
		if t, ok := ctx.(IA_expr_likeContext); ok {
			tst[i] = t.(IA_expr_likeContext)
			i++
		}
	}

	return tst
}

func (s *A_expr_compareContext) A_expr_like(i int) IA_expr_likeContext {
	var t antlr.RuleContext
	j := 0
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IA_expr_likeContext); ok {
			if j == i {
				t = ctx.(antlr.RuleContext)
				break
			}
			j++
		}
	}

	if t == nil {
		return nil
	}

	return t.(IA_expr_likeContext)
}

func (s *A_expr_compareContext) Subquery_Op() ISubquery_OpContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ISubquery_OpContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ISubquery_OpContext)
}

func (s *A_expr_compareContext) Sub_type() ISub_typeContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ISub_typeContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ISub_typeContext)
}

func (s *A_expr_compareContext) LT() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserLT, 0)
}

func (s *A_expr_compareContext) GT() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserGT, 0)
}

func (s *A_expr_compareContext) EQUAL() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserEQUAL, 0)
}

func (s *A_expr_compareContext) LESS_EQUALS() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserLESS_EQUALS, 0)
}

func (s *A_expr_compareContext) GREATER_EQUALS() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserGREATER_EQUALS, 0)
}

func (s *A_expr_compareContext) NOT_EQUALS() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserNOT_EQUALS, 0)
}

func (s *A_expr_compareContext) Select_with_parens() ISelect_with_parensContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ISelect_with_parensContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ISelect_with_parensContext)
}

func (s *A_expr_compareContext) OPEN_PAREN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserOPEN_PAREN, 0)
}

func (s *A_expr_compareContext) A_expr() IA_exprContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IA_exprContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IA_exprContext)
}

func (s *A_expr_compareContext) CLOSE_PAREN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCLOSE_PAREN, 0)
}

func (s *A_expr_compareContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *A_expr_compareContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *A_expr_compareContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterA_expr_compare(s)
	}
}

func (s *A_expr_compareContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitA_expr_compare(s)
	}
}

func (s *A_expr_compareContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitA_expr_compare(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) A_expr_compare() (localctx IA_expr_compareContext) {
	localctx = NewA_expr_compareContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1182, PostgreSQLParserRULE_a_expr_compare)
	var _la int

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(8885)
		p.A_expr_like()
	}
	p.SetState(8897)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 557, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(8886)
			_la = p.GetTokenStream().LA(1)

			if !((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&44237824) != 0) {
				p.GetErrorHandler().RecoverInline(p)
			} else {
				p.GetErrorHandler().ReportMatch(p)
				p.Consume()
			}
		}
		{
			p.SetState(8887)
			p.A_expr_like()
		}

	} else if p.HasError() { // JIM
		goto errorExit
	} else if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 557, p.GetParserRuleContext()) == 2 {
		{
			p.SetState(8888)
			p.Subquery_Op()
		}
		{
			p.SetState(8889)
			p.Sub_type()
		}
		p.SetState(8895)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}

		switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 556, p.GetParserRuleContext()) {
		case 1:
			{
				p.SetState(8890)
				p.Select_with_parens()
			}

		case 2:
			{
				p.SetState(8891)
				p.Match(PostgreSQLParserOPEN_PAREN)
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}
			{
				p.SetState(8892)
				p.A_expr()
			}
			{
				p.SetState(8893)
				p.Match(PostgreSQLParserCLOSE_PAREN)
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}

		case antlr.ATNInvalidAltNumber:
			goto errorExit
		}

	} else if p.HasError() { // JIM
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IA_expr_likeContext is an interface to support dynamic dispatch.
type IA_expr_likeContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	AllA_expr_qual_op() []IA_expr_qual_opContext
	A_expr_qual_op(i int) IA_expr_qual_opContext
	Opt_escape() IOpt_escapeContext
	LIKE() antlr.TerminalNode
	ILIKE() antlr.TerminalNode
	SIMILAR() antlr.TerminalNode
	TO() antlr.TerminalNode
	NOT() antlr.TerminalNode

	// IsA_expr_likeContext differentiates from other interfaces.
	IsA_expr_likeContext()
}

type A_expr_likeContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyA_expr_likeContext() *A_expr_likeContext {
	var p = new(A_expr_likeContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_a_expr_like
	return p
}

func InitEmptyA_expr_likeContext(p *A_expr_likeContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_a_expr_like
}

func (*A_expr_likeContext) IsA_expr_likeContext() {}

func NewA_expr_likeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *A_expr_likeContext {
	var p = new(A_expr_likeContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_a_expr_like

	return p
}

func (s *A_expr_likeContext) GetParser() antlr.Parser { return s.parser }

func (s *A_expr_likeContext) AllA_expr_qual_op() []IA_expr_qual_opContext {
	children := s.GetChildren()
	len := 0
	for _, ctx := range children {
		if _, ok := ctx.(IA_expr_qual_opContext); ok {
			len++
		}
	}

	tst := make([]IA_expr_qual_opContext, len)
	i := 0
	for _, ctx := range children {
		if t, ok := ctx.(IA_expr_qual_opContext); ok {
			tst[i] = t.(IA_expr_qual_opContext)
			i++
		}
	}

	return tst
}

func (s *A_expr_likeContext) A_expr_qual_op(i int) IA_expr_qual_opContext {
	var t antlr.RuleContext
	j := 0
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IA_expr_qual_opContext); ok {
			if j == i {
				t = ctx.(antlr.RuleContext)
				break
			}
			j++
		}
	}

	if t == nil {
		return nil
	}

	return t.(IA_expr_qual_opContext)
}

func (s *A_expr_likeContext) Opt_escape() IOpt_escapeContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOpt_escapeContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOpt_escapeContext)
}

func (s *A_expr_likeContext) LIKE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserLIKE, 0)
}

func (s *A_expr_likeContext) ILIKE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserILIKE, 0)
}

func (s *A_expr_likeContext) SIMILAR() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserSIMILAR, 0)
}

func (s *A_expr_likeContext) TO() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserTO, 0)
}

func (s *A_expr_likeContext) NOT() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserNOT, 0)
}

func (s *A_expr_likeContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *A_expr_likeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *A_expr_likeContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterA_expr_like(s)
	}
}

func (s *A_expr_likeContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitA_expr_like(s)
	}
}

func (s *A_expr_likeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitA_expr_like(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) A_expr_like() (localctx IA_expr_likeContext) {
	localctx = NewA_expr_likeContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1184, PostgreSQLParserRULE_a_expr_like)
	var _la int

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(8899)
		p.A_expr_qual_op()
	}
	p.SetState(8912)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 560, p.GetParserRuleContext()) == 1 {
		p.SetState(8901)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}
		_la = p.GetTokenStream().LA(1)

		if _la == PostgreSQLParserNOT {
			{
				p.SetState(8900)
				p.Match(PostgreSQLParserNOT)
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}

		}
		p.SetState(8907)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}

		switch p.GetTokenStream().LA(1) {
		case PostgreSQLParserLIKE:
			{
				p.SetState(8903)
				p.Match(PostgreSQLParserLIKE)
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}

		case PostgreSQLParserILIKE:
			{
				p.SetState(8904)
				p.Match(PostgreSQLParserILIKE)
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}

		case PostgreSQLParserSIMILAR:
			{
				p.SetState(8905)
				p.Match(PostgreSQLParserSIMILAR)
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}
			{
				p.SetState(8906)
				p.Match(PostgreSQLParserTO)
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}

		default:
			p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
			goto errorExit
		}
		{
			p.SetState(8909)
			p.A_expr_qual_op()
		}
		{
			p.SetState(8910)
			p.Opt_escape()
		}

	} else if p.HasError() { // JIM
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IA_expr_qual_opContext is an interface to support dynamic dispatch.
type IA_expr_qual_opContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	AllA_expr_unary_qualop() []IA_expr_unary_qualopContext
	A_expr_unary_qualop(i int) IA_expr_unary_qualopContext
	AllQual_op() []IQual_opContext
	Qual_op(i int) IQual_opContext

	// IsA_expr_qual_opContext differentiates from other interfaces.
	IsA_expr_qual_opContext()
}

type A_expr_qual_opContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyA_expr_qual_opContext() *A_expr_qual_opContext {
	var p = new(A_expr_qual_opContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_a_expr_qual_op
	return p
}

func InitEmptyA_expr_qual_opContext(p *A_expr_qual_opContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_a_expr_qual_op
}

func (*A_expr_qual_opContext) IsA_expr_qual_opContext() {}

func NewA_expr_qual_opContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *A_expr_qual_opContext {
	var p = new(A_expr_qual_opContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_a_expr_qual_op

	return p
}

func (s *A_expr_qual_opContext) GetParser() antlr.Parser { return s.parser }

func (s *A_expr_qual_opContext) AllA_expr_unary_qualop() []IA_expr_unary_qualopContext {
	children := s.GetChildren()
	len := 0
	for _, ctx := range children {
		if _, ok := ctx.(IA_expr_unary_qualopContext); ok {
			len++
		}
	}

	tst := make([]IA_expr_unary_qualopContext, len)
	i := 0
	for _, ctx := range children {
		if t, ok := ctx.(IA_expr_unary_qualopContext); ok {
			tst[i] = t.(IA_expr_unary_qualopContext)
			i++
		}
	}

	return tst
}

func (s *A_expr_qual_opContext) A_expr_unary_qualop(i int) IA_expr_unary_qualopContext {
	var t antlr.RuleContext
	j := 0
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IA_expr_unary_qualopContext); ok {
			if j == i {
				t = ctx.(antlr.RuleContext)
				break
			}
			j++
		}
	}

	if t == nil {
		return nil
	}

	return t.(IA_expr_unary_qualopContext)
}

func (s *A_expr_qual_opContext) AllQual_op() []IQual_opContext {
	children := s.GetChildren()
	len := 0
	for _, ctx := range children {
		if _, ok := ctx.(IQual_opContext); ok {
			len++
		}
	}

	tst := make([]IQual_opContext, len)
	i := 0
	for _, ctx := range children {
		if t, ok := ctx.(IQual_opContext); ok {
			tst[i] = t.(IQual_opContext)
			i++
		}
	}

	return tst
}

func (s *A_expr_qual_opContext) Qual_op(i int) IQual_opContext {
	var t antlr.RuleContext
	j := 0
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IQual_opContext); ok {
			if j == i {
				t = ctx.(antlr.RuleContext)
				break
			}
			j++
		}
	}

	if t == nil {
		return nil
	}

	return t.(IQual_opContext)
}

func (s *A_expr_qual_opContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *A_expr_qual_opContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *A_expr_qual_opContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterA_expr_qual_op(s)
	}
}

func (s *A_expr_qual_opContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitA_expr_qual_op(s)
	}
}

func (s *A_expr_qual_opContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitA_expr_qual_op(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) A_expr_qual_op() (localctx IA_expr_qual_opContext) {
	localctx = NewA_expr_qual_opContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1186, PostgreSQLParserRULE_a_expr_qual_op)
	var _alt int

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(8914)
		p.A_expr_unary_qualop()
	}
	p.SetState(8920)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}
	_alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 561, p.GetParserRuleContext())
	if p.HasError() {
		goto errorExit
	}
	for _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
		if _alt == 1 {
			{
				p.SetState(8915)
				p.Qual_op()
			}
			{
				p.SetState(8916)
				p.A_expr_unary_qualop()
			}

		}
		p.SetState(8922)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}
		_alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 561, p.GetParserRuleContext())
		if p.HasError() {
			goto errorExit
		}
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IA_expr_unary_qualopContext is an interface to support dynamic dispatch.
type IA_expr_unary_qualopContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	A_expr_add() IA_expr_addContext
	Qual_op() IQual_opContext

	// IsA_expr_unary_qualopContext differentiates from other interfaces.
	IsA_expr_unary_qualopContext()
}

type A_expr_unary_qualopContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyA_expr_unary_qualopContext() *A_expr_unary_qualopContext {
	var p = new(A_expr_unary_qualopContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_a_expr_unary_qualop
	return p
}

func InitEmptyA_expr_unary_qualopContext(p *A_expr_unary_qualopContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_a_expr_unary_qualop
}

func (*A_expr_unary_qualopContext) IsA_expr_unary_qualopContext() {}

func NewA_expr_unary_qualopContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *A_expr_unary_qualopContext {
	var p = new(A_expr_unary_qualopContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_a_expr_unary_qualop

	return p
}

func (s *A_expr_unary_qualopContext) GetParser() antlr.Parser { return s.parser }

func (s *A_expr_unary_qualopContext) A_expr_add() IA_expr_addContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IA_expr_addContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IA_expr_addContext)
}

func (s *A_expr_unary_qualopContext) Qual_op() IQual_opContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IQual_opContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IQual_opContext)
}

func (s *A_expr_unary_qualopContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *A_expr_unary_qualopContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *A_expr_unary_qualopContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterA_expr_unary_qualop(s)
	}
}

func (s *A_expr_unary_qualopContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitA_expr_unary_qualop(s)
	}
}

func (s *A_expr_unary_qualopContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitA_expr_unary_qualop(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) A_expr_unary_qualop() (localctx IA_expr_unary_qualopContext) {
	localctx = NewA_expr_unary_qualopContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1188, PostgreSQLParserRULE_a_expr_unary_qualop)
	p.EnterOuterAlt(localctx, 1)
	p.SetState(8924)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 562, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(8923)
			p.Qual_op()
		}

	} else if p.HasError() { // JIM
		goto errorExit
	}
	{
		p.SetState(8926)
		p.A_expr_add()
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IA_expr_addContext is an interface to support dynamic dispatch.
type IA_expr_addContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	AllA_expr_mul() []IA_expr_mulContext
	A_expr_mul(i int) IA_expr_mulContext
	AllMINUS() []antlr.TerminalNode
	MINUS(i int) antlr.TerminalNode
	AllPLUS() []antlr.TerminalNode
	PLUS(i int) antlr.TerminalNode

	// IsA_expr_addContext differentiates from other interfaces.
	IsA_expr_addContext()
}

type A_expr_addContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyA_expr_addContext() *A_expr_addContext {
	var p = new(A_expr_addContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_a_expr_add
	return p
}

func InitEmptyA_expr_addContext(p *A_expr_addContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_a_expr_add
}

func (*A_expr_addContext) IsA_expr_addContext() {}

func NewA_expr_addContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *A_expr_addContext {
	var p = new(A_expr_addContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_a_expr_add

	return p
}

func (s *A_expr_addContext) GetParser() antlr.Parser { return s.parser }

func (s *A_expr_addContext) AllA_expr_mul() []IA_expr_mulContext {
	children := s.GetChildren()
	len := 0
	for _, ctx := range children {
		if _, ok := ctx.(IA_expr_mulContext); ok {
			len++
		}
	}

	tst := make([]IA_expr_mulContext, len)
	i := 0
	for _, ctx := range children {
		if t, ok := ctx.(IA_expr_mulContext); ok {
			tst[i] = t.(IA_expr_mulContext)
			i++
		}
	}

	return tst
}

func (s *A_expr_addContext) A_expr_mul(i int) IA_expr_mulContext {
	var t antlr.RuleContext
	j := 0
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IA_expr_mulContext); ok {
			if j == i {
				t = ctx.(antlr.RuleContext)
				break
			}
			j++
		}
	}

	if t == nil {
		return nil
	}

	return t.(IA_expr_mulContext)
}

func (s *A_expr_addContext) AllMINUS() []antlr.TerminalNode {
	return s.GetTokens(PostgreSQLParserMINUS)
}

func (s *A_expr_addContext) MINUS(i int) antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserMINUS, i)
}

func (s *A_expr_addContext) AllPLUS() []antlr.TerminalNode {
	return s.GetTokens(PostgreSQLParserPLUS)
}

func (s *A_expr_addContext) PLUS(i int) antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserPLUS, i)
}

func (s *A_expr_addContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *A_expr_addContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *A_expr_addContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterA_expr_add(s)
	}
}

func (s *A_expr_addContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitA_expr_add(s)
	}
}

func (s *A_expr_addContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitA_expr_add(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) A_expr_add() (localctx IA_expr_addContext) {
	localctx = NewA_expr_addContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1190, PostgreSQLParserRULE_a_expr_add)
	var _la int

	var _alt int

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(8928)
		p.A_expr_mul()
	}
	p.SetState(8933)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}
	_alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 563, p.GetParserRuleContext())
	if p.HasError() {
		goto errorExit
	}
	for _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
		if _alt == 1 {
			{
				p.SetState(8929)
				_la = p.GetTokenStream().LA(1)

				if !(_la == PostgreSQLParserPLUS || _la == PostgreSQLParserMINUS) {
					p.GetErrorHandler().RecoverInline(p)
				} else {
					p.GetErrorHandler().ReportMatch(p)
					p.Consume()
				}
			}
			{
				p.SetState(8930)
				p.A_expr_mul()
			}

		}
		p.SetState(8935)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}
		_alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 563, p.GetParserRuleContext())
		if p.HasError() {
			goto errorExit
		}
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IA_expr_mulContext is an interface to support dynamic dispatch.
type IA_expr_mulContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	AllA_expr_caret() []IA_expr_caretContext
	A_expr_caret(i int) IA_expr_caretContext
	AllSTAR() []antlr.TerminalNode
	STAR(i int) antlr.TerminalNode
	AllSLASH() []antlr.TerminalNode
	SLASH(i int) antlr.TerminalNode
	AllPERCENT() []antlr.TerminalNode
	PERCENT(i int) antlr.TerminalNode

	// IsA_expr_mulContext differentiates from other interfaces.
	IsA_expr_mulContext()
}

type A_expr_mulContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyA_expr_mulContext() *A_expr_mulContext {
	var p = new(A_expr_mulContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_a_expr_mul
	return p
}

func InitEmptyA_expr_mulContext(p *A_expr_mulContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_a_expr_mul
}

func (*A_expr_mulContext) IsA_expr_mulContext() {}

func NewA_expr_mulContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *A_expr_mulContext {
	var p = new(A_expr_mulContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_a_expr_mul

	return p
}

func (s *A_expr_mulContext) GetParser() antlr.Parser { return s.parser }

func (s *A_expr_mulContext) AllA_expr_caret() []IA_expr_caretContext {
	children := s.GetChildren()
	len := 0
	for _, ctx := range children {
		if _, ok := ctx.(IA_expr_caretContext); ok {
			len++
		}
	}

	tst := make([]IA_expr_caretContext, len)
	i := 0
	for _, ctx := range children {
		if t, ok := ctx.(IA_expr_caretContext); ok {
			tst[i] = t.(IA_expr_caretContext)
			i++
		}
	}

	return tst
}

func (s *A_expr_mulContext) A_expr_caret(i int) IA_expr_caretContext {
	var t antlr.RuleContext
	j := 0
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IA_expr_caretContext); ok {
			if j == i {
				t = ctx.(antlr.RuleContext)
				break
			}
			j++
		}
	}

	if t == nil {
		return nil
	}

	return t.(IA_expr_caretContext)
}

func (s *A_expr_mulContext) AllSTAR() []antlr.TerminalNode {
	return s.GetTokens(PostgreSQLParserSTAR)
}

func (s *A_expr_mulContext) STAR(i int) antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserSTAR, i)
}

func (s *A_expr_mulContext) AllSLASH() []antlr.TerminalNode {
	return s.GetTokens(PostgreSQLParserSLASH)
}

func (s *A_expr_mulContext) SLASH(i int) antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserSLASH, i)
}

func (s *A_expr_mulContext) AllPERCENT() []antlr.TerminalNode {
	return s.GetTokens(PostgreSQLParserPERCENT)
}

func (s *A_expr_mulContext) PERCENT(i int) antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserPERCENT, i)
}

func (s *A_expr_mulContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *A_expr_mulContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *A_expr_mulContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterA_expr_mul(s)
	}
}

func (s *A_expr_mulContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitA_expr_mul(s)
	}
}

func (s *A_expr_mulContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitA_expr_mul(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) A_expr_mul() (localctx IA_expr_mulContext) {
	localctx = NewA_expr_mulContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1192, PostgreSQLParserRULE_a_expr_mul)
	var _la int

	var _alt int

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(8936)
		p.A_expr_caret()
	}
	p.SetState(8941)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}
	_alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 564, p.GetParserRuleContext())
	if p.HasError() {
		goto errorExit
	}
	for _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
		if _alt == 1 {
			{
				p.SetState(8937)
				_la = p.GetTokenStream().LA(1)

				if !((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&134234624) != 0) {
					p.GetErrorHandler().RecoverInline(p)
				} else {
					p.GetErrorHandler().ReportMatch(p)
					p.Consume()
				}
			}
			{
				p.SetState(8938)
				p.A_expr_caret()
			}

		}
		p.SetState(8943)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}
		_alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 564, p.GetParserRuleContext())
		if p.HasError() {
			goto errorExit
		}
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IA_expr_caretContext is an interface to support dynamic dispatch.
type IA_expr_caretContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	A_expr_unary_sign() IA_expr_unary_signContext
	CARET() antlr.TerminalNode
	A_expr() IA_exprContext

	// IsA_expr_caretContext differentiates from other interfaces.
	IsA_expr_caretContext()
}

type A_expr_caretContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyA_expr_caretContext() *A_expr_caretContext {
	var p = new(A_expr_caretContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_a_expr_caret
	return p
}

func InitEmptyA_expr_caretContext(p *A_expr_caretContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_a_expr_caret
}

func (*A_expr_caretContext) IsA_expr_caretContext() {}

func NewA_expr_caretContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *A_expr_caretContext {
	var p = new(A_expr_caretContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_a_expr_caret

	return p
}

func (s *A_expr_caretContext) GetParser() antlr.Parser { return s.parser }

func (s *A_expr_caretContext) A_expr_unary_sign() IA_expr_unary_signContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IA_expr_unary_signContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IA_expr_unary_signContext)
}

func (s *A_expr_caretContext) CARET() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCARET, 0)
}

func (s *A_expr_caretContext) A_expr() IA_exprContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IA_exprContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IA_exprContext)
}

func (s *A_expr_caretContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *A_expr_caretContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *A_expr_caretContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterA_expr_caret(s)
	}
}

func (s *A_expr_caretContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitA_expr_caret(s)
	}
}

func (s *A_expr_caretContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitA_expr_caret(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) A_expr_caret() (localctx IA_expr_caretContext) {
	localctx = NewA_expr_caretContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1194, PostgreSQLParserRULE_a_expr_caret)
	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(8944)
		p.A_expr_unary_sign()
	}
	p.SetState(8947)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 565, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(8945)
			p.Match(PostgreSQLParserCARET)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(8946)
			p.A_expr()
		}

	} else if p.HasError() { // JIM
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IA_expr_unary_signContext is an interface to support dynamic dispatch.
type IA_expr_unary_signContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	A_expr_at_time_zone() IA_expr_at_time_zoneContext
	MINUS() antlr.TerminalNode
	PLUS() antlr.TerminalNode

	// IsA_expr_unary_signContext differentiates from other interfaces.
	IsA_expr_unary_signContext()
}

type A_expr_unary_signContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyA_expr_unary_signContext() *A_expr_unary_signContext {
	var p = new(A_expr_unary_signContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_a_expr_unary_sign
	return p
}

func InitEmptyA_expr_unary_signContext(p *A_expr_unary_signContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_a_expr_unary_sign
}

func (*A_expr_unary_signContext) IsA_expr_unary_signContext() {}

func NewA_expr_unary_signContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *A_expr_unary_signContext {
	var p = new(A_expr_unary_signContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_a_expr_unary_sign

	return p
}

func (s *A_expr_unary_signContext) GetParser() antlr.Parser { return s.parser }

func (s *A_expr_unary_signContext) A_expr_at_time_zone() IA_expr_at_time_zoneContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IA_expr_at_time_zoneContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IA_expr_at_time_zoneContext)
}

func (s *A_expr_unary_signContext) MINUS() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserMINUS, 0)
}

func (s *A_expr_unary_signContext) PLUS() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserPLUS, 0)
}

func (s *A_expr_unary_signContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *A_expr_unary_signContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *A_expr_unary_signContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterA_expr_unary_sign(s)
	}
}

func (s *A_expr_unary_signContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitA_expr_unary_sign(s)
	}
}

func (s *A_expr_unary_signContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitA_expr_unary_sign(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) A_expr_unary_sign() (localctx IA_expr_unary_signContext) {
	localctx = NewA_expr_unary_signContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1196, PostgreSQLParserRULE_a_expr_unary_sign)
	var _la int

	p.EnterOuterAlt(localctx, 1)
	p.SetState(8950)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}
	_la = p.GetTokenStream().LA(1)

	if _la == PostgreSQLParserPLUS || _la == PostgreSQLParserMINUS {
		{
			p.SetState(8949)
			_la = p.GetTokenStream().LA(1)

			if !(_la == PostgreSQLParserPLUS || _la == PostgreSQLParserMINUS) {
				p.GetErrorHandler().RecoverInline(p)
			} else {
				p.GetErrorHandler().ReportMatch(p)
				p.Consume()
			}
		}

	}
	{
		p.SetState(8952)
		p.A_expr_at_time_zone()
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IA_expr_at_time_zoneContext is an interface to support dynamic dispatch.
type IA_expr_at_time_zoneContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	A_expr_collate() IA_expr_collateContext
	AT() antlr.TerminalNode
	TIME() antlr.TerminalNode
	ZONE() antlr.TerminalNode
	A_expr() IA_exprContext

	// IsA_expr_at_time_zoneContext differentiates from other interfaces.
	IsA_expr_at_time_zoneContext()
}

type A_expr_at_time_zoneContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyA_expr_at_time_zoneContext() *A_expr_at_time_zoneContext {
	var p = new(A_expr_at_time_zoneContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_a_expr_at_time_zone
	return p
}

func InitEmptyA_expr_at_time_zoneContext(p *A_expr_at_time_zoneContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_a_expr_at_time_zone
}

func (*A_expr_at_time_zoneContext) IsA_expr_at_time_zoneContext() {}

func NewA_expr_at_time_zoneContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *A_expr_at_time_zoneContext {
	var p = new(A_expr_at_time_zoneContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_a_expr_at_time_zone

	return p
}

func (s *A_expr_at_time_zoneContext) GetParser() antlr.Parser { return s.parser }

func (s *A_expr_at_time_zoneContext) A_expr_collate() IA_expr_collateContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IA_expr_collateContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IA_expr_collateContext)
}

func (s *A_expr_at_time_zoneContext) AT() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserAT, 0)
}

func (s *A_expr_at_time_zoneContext) TIME() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserTIME, 0)
}

func (s *A_expr_at_time_zoneContext) ZONE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserZONE, 0)
}

func (s *A_expr_at_time_zoneContext) A_expr() IA_exprContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IA_exprContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IA_exprContext)
}

func (s *A_expr_at_time_zoneContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *A_expr_at_time_zoneContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *A_expr_at_time_zoneContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterA_expr_at_time_zone(s)
	}
}

func (s *A_expr_at_time_zoneContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitA_expr_at_time_zone(s)
	}
}

func (s *A_expr_at_time_zoneContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitA_expr_at_time_zone(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) A_expr_at_time_zone() (localctx IA_expr_at_time_zoneContext) {
	localctx = NewA_expr_at_time_zoneContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1198, PostgreSQLParserRULE_a_expr_at_time_zone)
	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(8954)
		p.A_expr_collate()
	}
	p.SetState(8959)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 567, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(8955)
			p.Match(PostgreSQLParserAT)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(8956)
			p.Match(PostgreSQLParserTIME)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(8957)
			p.Match(PostgreSQLParserZONE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(8958)
			p.A_expr()
		}

	} else if p.HasError() { // JIM
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IA_expr_collateContext is an interface to support dynamic dispatch.
type IA_expr_collateContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	A_expr_typecast() IA_expr_typecastContext
	COLLATE() antlr.TerminalNode
	Any_name() IAny_nameContext

	// IsA_expr_collateContext differentiates from other interfaces.
	IsA_expr_collateContext()
}

type A_expr_collateContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyA_expr_collateContext() *A_expr_collateContext {
	var p = new(A_expr_collateContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_a_expr_collate
	return p
}

func InitEmptyA_expr_collateContext(p *A_expr_collateContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_a_expr_collate
}

func (*A_expr_collateContext) IsA_expr_collateContext() {}

func NewA_expr_collateContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *A_expr_collateContext {
	var p = new(A_expr_collateContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_a_expr_collate

	return p
}

func (s *A_expr_collateContext) GetParser() antlr.Parser { return s.parser }

func (s *A_expr_collateContext) A_expr_typecast() IA_expr_typecastContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IA_expr_typecastContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IA_expr_typecastContext)
}

func (s *A_expr_collateContext) COLLATE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCOLLATE, 0)
}

func (s *A_expr_collateContext) Any_name() IAny_nameContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IAny_nameContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IAny_nameContext)
}

func (s *A_expr_collateContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *A_expr_collateContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *A_expr_collateContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterA_expr_collate(s)
	}
}

func (s *A_expr_collateContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitA_expr_collate(s)
	}
}

func (s *A_expr_collateContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitA_expr_collate(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) A_expr_collate() (localctx IA_expr_collateContext) {
	localctx = NewA_expr_collateContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1200, PostgreSQLParserRULE_a_expr_collate)
	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(8961)
		p.A_expr_typecast()
	}
	p.SetState(8964)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 568, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(8962)
			p.Match(PostgreSQLParserCOLLATE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(8963)
			p.Any_name()
		}

	} else if p.HasError() { // JIM
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IA_expr_typecastContext is an interface to support dynamic dispatch.
type IA_expr_typecastContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	C_expr() IC_exprContext
	AllTYPECAST() []antlr.TerminalNode
	TYPECAST(i int) antlr.TerminalNode
	AllTypename() []ITypenameContext
	Typename(i int) ITypenameContext

	// IsA_expr_typecastContext differentiates from other interfaces.
	IsA_expr_typecastContext()
}

type A_expr_typecastContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyA_expr_typecastContext() *A_expr_typecastContext {
	var p = new(A_expr_typecastContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_a_expr_typecast
	return p
}

func InitEmptyA_expr_typecastContext(p *A_expr_typecastContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_a_expr_typecast
}

func (*A_expr_typecastContext) IsA_expr_typecastContext() {}

func NewA_expr_typecastContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *A_expr_typecastContext {
	var p = new(A_expr_typecastContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_a_expr_typecast

	return p
}

func (s *A_expr_typecastContext) GetParser() antlr.Parser { return s.parser }

func (s *A_expr_typecastContext) C_expr() IC_exprContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IC_exprContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IC_exprContext)
}

func (s *A_expr_typecastContext) AllTYPECAST() []antlr.TerminalNode {
	return s.GetTokens(PostgreSQLParserTYPECAST)
}

func (s *A_expr_typecastContext) TYPECAST(i int) antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserTYPECAST, i)
}

func (s *A_expr_typecastContext) AllTypename() []ITypenameContext {
	children := s.GetChildren()
	len := 0
	for _, ctx := range children {
		if _, ok := ctx.(ITypenameContext); ok {
			len++
		}
	}

	tst := make([]ITypenameContext, len)
	i := 0
	for _, ctx := range children {
		if t, ok := ctx.(ITypenameContext); ok {
			tst[i] = t.(ITypenameContext)
			i++
		}
	}

	return tst
}

func (s *A_expr_typecastContext) Typename(i int) ITypenameContext {
	var t antlr.RuleContext
	j := 0
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ITypenameContext); ok {
			if j == i {
				t = ctx.(antlr.RuleContext)
				break
			}
			j++
		}
	}

	if t == nil {
		return nil
	}

	return t.(ITypenameContext)
}

func (s *A_expr_typecastContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *A_expr_typecastContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *A_expr_typecastContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterA_expr_typecast(s)
	}
}

func (s *A_expr_typecastContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitA_expr_typecast(s)
	}
}

func (s *A_expr_typecastContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitA_expr_typecast(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) A_expr_typecast() (localctx IA_expr_typecastContext) {
	localctx = NewA_expr_typecastContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1202, PostgreSQLParserRULE_a_expr_typecast)
	var _la int

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(8966)
		p.C_expr()
	}
	p.SetState(8971)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}
	_la = p.GetTokenStream().LA(1)

	for _la == PostgreSQLParserTYPECAST {
		{
			p.SetState(8967)
			p.Match(PostgreSQLParserTYPECAST)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(8968)
			p.Typename()
		}

		p.SetState(8973)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}
		_la = p.GetTokenStream().LA(1)
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IB_exprContext is an interface to support dynamic dispatch.
type IB_exprContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	C_expr() IC_exprContext
	AllB_expr() []IB_exprContext
	B_expr(i int) IB_exprContext
	PLUS() antlr.TerminalNode
	MINUS() antlr.TerminalNode
	Qual_op() IQual_opContext
	CARET() antlr.TerminalNode
	STAR() antlr.TerminalNode
	SLASH() antlr.TerminalNode
	PERCENT() antlr.TerminalNode
	LT() antlr.TerminalNode
	GT() antlr.TerminalNode
	EQUAL() antlr.TerminalNode
	LESS_EQUALS() antlr.TerminalNode
	GREATER_EQUALS() antlr.TerminalNode
	NOT_EQUALS() antlr.TerminalNode
	TYPECAST() antlr.TerminalNode
	Typename() ITypenameContext
	IS() antlr.TerminalNode
	DISTINCT() antlr.TerminalNode
	FROM() antlr.TerminalNode
	OF() antlr.TerminalNode
	OPEN_PAREN() antlr.TerminalNode
	Type_list() IType_listContext
	CLOSE_PAREN() antlr.TerminalNode
	DOCUMENT_P() antlr.TerminalNode
	NOT() antlr.TerminalNode

	// IsB_exprContext differentiates from other interfaces.
	IsB_exprContext()
}

type B_exprContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyB_exprContext() *B_exprContext {
	var p = new(B_exprContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_b_expr
	return p
}

func InitEmptyB_exprContext(p *B_exprContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_b_expr
}

func (*B_exprContext) IsB_exprContext() {}

func NewB_exprContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *B_exprContext {
	var p = new(B_exprContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_b_expr

	return p
}

func (s *B_exprContext) GetParser() antlr.Parser { return s.parser }

func (s *B_exprContext) C_expr() IC_exprContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IC_exprContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IC_exprContext)
}

func (s *B_exprContext) AllB_expr() []IB_exprContext {
	children := s.GetChildren()
	len := 0
	for _, ctx := range children {
		if _, ok := ctx.(IB_exprContext); ok {
			len++
		}
	}

	tst := make([]IB_exprContext, len)
	i := 0
	for _, ctx := range children {
		if t, ok := ctx.(IB_exprContext); ok {
			tst[i] = t.(IB_exprContext)
			i++
		}
	}

	return tst
}

func (s *B_exprContext) B_expr(i int) IB_exprContext {
	var t antlr.RuleContext
	j := 0
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IB_exprContext); ok {
			if j == i {
				t = ctx.(antlr.RuleContext)
				break
			}
			j++
		}
	}

	if t == nil {
		return nil
	}

	return t.(IB_exprContext)
}

func (s *B_exprContext) PLUS() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserPLUS, 0)
}

func (s *B_exprContext) MINUS() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserMINUS, 0)
}

func (s *B_exprContext) Qual_op() IQual_opContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IQual_opContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IQual_opContext)
}

func (s *B_exprContext) CARET() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCARET, 0)
}

func (s *B_exprContext) STAR() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserSTAR, 0)
}

func (s *B_exprContext) SLASH() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserSLASH, 0)
}

func (s *B_exprContext) PERCENT() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserPERCENT, 0)
}

func (s *B_exprContext) LT() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserLT, 0)
}

func (s *B_exprContext) GT() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserGT, 0)
}

func (s *B_exprContext) EQUAL() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserEQUAL, 0)
}

func (s *B_exprContext) LESS_EQUALS() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserLESS_EQUALS, 0)
}

func (s *B_exprContext) GREATER_EQUALS() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserGREATER_EQUALS, 0)
}

func (s *B_exprContext) NOT_EQUALS() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserNOT_EQUALS, 0)
}

func (s *B_exprContext) TYPECAST() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserTYPECAST, 0)
}

func (s *B_exprContext) Typename() ITypenameContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ITypenameContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ITypenameContext)
}

func (s *B_exprContext) IS() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserIS, 0)
}

func (s *B_exprContext) DISTINCT() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserDISTINCT, 0)
}

func (s *B_exprContext) FROM() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserFROM, 0)
}

func (s *B_exprContext) OF() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserOF, 0)
}

func (s *B_exprContext) OPEN_PAREN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserOPEN_PAREN, 0)
}

func (s *B_exprContext) Type_list() IType_listContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IType_listContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IType_listContext)
}

func (s *B_exprContext) CLOSE_PAREN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCLOSE_PAREN, 0)
}

func (s *B_exprContext) DOCUMENT_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserDOCUMENT_P, 0)
}

func (s *B_exprContext) NOT() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserNOT, 0)
}

func (s *B_exprContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *B_exprContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *B_exprContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterB_expr(s)
	}
}

func (s *B_exprContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitB_expr(s)
	}
}

func (s *B_exprContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitB_expr(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) B_expr() (localctx IB_exprContext) {
	return p.b_expr(0)
}

func (p *PostgreSQLParser) b_expr(_p int) (localctx IB_exprContext) {
	var _parentctx antlr.ParserRuleContext = p.GetParserRuleContext()

	_parentState := p.GetState()
	localctx = NewB_exprContext(p, p.GetParserRuleContext(), _parentState)
	var _prevctx IB_exprContext = localctx
	var _ antlr.ParserRuleContext = _prevctx // TODO: To prevent unused variable warning.
	_startState := 1204
	p.EnterRecursionRule(localctx, 1204, PostgreSQLParserRULE_b_expr, _p)
	var _la int

	var _alt int

	p.EnterOuterAlt(localctx, 1)
	p.SetState(8981)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 570, p.GetParserRuleContext()) {
	case 1:
		{
			p.SetState(8975)
			p.C_expr()
		}

	case 2:
		{
			p.SetState(8976)
			_la = p.GetTokenStream().LA(1)

			if !(_la == PostgreSQLParserPLUS || _la == PostgreSQLParserMINUS) {
				p.GetErrorHandler().RecoverInline(p)
			} else {
				p.GetErrorHandler().ReportMatch(p)
				p.Consume()
			}
		}
		{
			p.SetState(8977)
			p.b_expr(9)
		}

	case 3:
		{
			p.SetState(8978)
			p.Qual_op()
		}
		{
			p.SetState(8979)
			p.b_expr(3)
		}

	case antlr.ATNInvalidAltNumber:
		goto errorExit
	}
	p.GetParserRuleContext().SetStop(p.GetTokenStream().LT(-1))
	p.SetState(9022)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}
	_alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 574, p.GetParserRuleContext())
	if p.HasError() {
		goto errorExit
	}
	for _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
		if _alt == 1 {
			if p.GetParseListeners() != nil {
				p.TriggerExitRuleEvent()
			}
			_prevctx = localctx
			p.SetState(9020)
			p.GetErrorHandler().Sync(p)
			if p.HasError() {
				goto errorExit
			}

			switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 573, p.GetParserRuleContext()) {
			case 1:
				localctx = NewB_exprContext(p, _parentctx, _parentState)
				p.PushNewRecursionContext(localctx, _startState, PostgreSQLParserRULE_b_expr)
				p.SetState(8983)

				if !(p.Precpred(p.GetParserRuleContext(), 8)) {
					p.SetError(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 8)", ""))
					goto errorExit
				}
				{
					p.SetState(8984)
					p.Match(PostgreSQLParserCARET)
					if p.HasError() {
						// Recognition error - abort rule
						goto errorExit
					}
				}
				{
					p.SetState(8985)
					p.b_expr(9)
				}

			case 2:
				localctx = NewB_exprContext(p, _parentctx, _parentState)
				p.PushNewRecursionContext(localctx, _startState, PostgreSQLParserRULE_b_expr)
				p.SetState(8986)

				if !(p.Precpred(p.GetParserRuleContext(), 7)) {
					p.SetError(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 7)", ""))
					goto errorExit
				}
				{
					p.SetState(8987)
					_la = p.GetTokenStream().LA(1)

					if !((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&134234624) != 0) {
						p.GetErrorHandler().RecoverInline(p)
					} else {
						p.GetErrorHandler().ReportMatch(p)
						p.Consume()
					}
				}
				{
					p.SetState(8988)
					p.b_expr(8)
				}

			case 3:
				localctx = NewB_exprContext(p, _parentctx, _parentState)
				p.PushNewRecursionContext(localctx, _startState, PostgreSQLParserRULE_b_expr)
				p.SetState(8989)

				if !(p.Precpred(p.GetParserRuleContext(), 6)) {
					p.SetError(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 6)", ""))
					goto errorExit
				}
				{
					p.SetState(8990)
					_la = p.GetTokenStream().LA(1)

					if !(_la == PostgreSQLParserPLUS || _la == PostgreSQLParserMINUS) {
						p.GetErrorHandler().RecoverInline(p)
					} else {
						p.GetErrorHandler().ReportMatch(p)
						p.Consume()
					}
				}
				{
					p.SetState(8991)
					p.b_expr(7)
				}

			case 4:
				localctx = NewB_exprContext(p, _parentctx, _parentState)
				p.PushNewRecursionContext(localctx, _startState, PostgreSQLParserRULE_b_expr)
				p.SetState(8992)

				if !(p.Precpred(p.GetParserRuleContext(), 5)) {
					p.SetError(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 5)", ""))
					goto errorExit
				}
				{
					p.SetState(8993)
					p.Qual_op()
				}
				{
					p.SetState(8994)
					p.b_expr(6)
				}

			case 5:
				localctx = NewB_exprContext(p, _parentctx, _parentState)
				p.PushNewRecursionContext(localctx, _startState, PostgreSQLParserRULE_b_expr)
				p.SetState(8996)

				if !(p.Precpred(p.GetParserRuleContext(), 4)) {
					p.SetError(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 4)", ""))
					goto errorExit
				}
				{
					p.SetState(8997)
					_la = p.GetTokenStream().LA(1)

					if !((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&44237824) != 0) {
						p.GetErrorHandler().RecoverInline(p)
					} else {
						p.GetErrorHandler().ReportMatch(p)
						p.Consume()
					}
				}
				{
					p.SetState(8998)
					p.b_expr(5)
				}

			case 6:
				localctx = NewB_exprContext(p, _parentctx, _parentState)
				p.PushNewRecursionContext(localctx, _startState, PostgreSQLParserRULE_b_expr)
				p.SetState(8999)

				if !(p.Precpred(p.GetParserRuleContext(), 10)) {
					p.SetError(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 10)", ""))
					goto errorExit
				}
				{
					p.SetState(9000)
					p.Match(PostgreSQLParserTYPECAST)
					if p.HasError() {
						// Recognition error - abort rule
						goto errorExit
					}
				}
				{
					p.SetState(9001)
					p.Typename()
				}

			case 7:
				localctx = NewB_exprContext(p, _parentctx, _parentState)
				p.PushNewRecursionContext(localctx, _startState, PostgreSQLParserRULE_b_expr)
				p.SetState(9002)

				if !(p.Precpred(p.GetParserRuleContext(), 2)) {
					p.SetError(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 2)", ""))
					goto errorExit
				}
				{
					p.SetState(9003)
					p.Qual_op()
				}

			case 8:
				localctx = NewB_exprContext(p, _parentctx, _parentState)
				p.PushNewRecursionContext(localctx, _startState, PostgreSQLParserRULE_b_expr)
				p.SetState(9004)

				if !(p.Precpred(p.GetParserRuleContext(), 1)) {
					p.SetError(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 1)", ""))
					goto errorExit
				}
				{
					p.SetState(9005)
					p.Match(PostgreSQLParserIS)
					if p.HasError() {
						// Recognition error - abort rule
						goto errorExit
					}
				}
				p.SetState(9007)
				p.GetErrorHandler().Sync(p)
				if p.HasError() {
					goto errorExit
				}
				_la = p.GetTokenStream().LA(1)

				if _la == PostgreSQLParserNOT {
					{
						p.SetState(9006)
						p.Match(PostgreSQLParserNOT)
						if p.HasError() {
							// Recognition error - abort rule
							goto errorExit
						}
					}

				}
				p.SetState(9018)
				p.GetErrorHandler().Sync(p)
				if p.HasError() {
					goto errorExit
				}

				switch p.GetTokenStream().LA(1) {
				case PostgreSQLParserDISTINCT:
					{
						p.SetState(9009)
						p.Match(PostgreSQLParserDISTINCT)
						if p.HasError() {
							// Recognition error - abort rule
							goto errorExit
						}
					}
					{
						p.SetState(9010)
						p.Match(PostgreSQLParserFROM)
						if p.HasError() {
							// Recognition error - abort rule
							goto errorExit
						}
					}
					{
						p.SetState(9011)
						p.b_expr(0)
					}

				case PostgreSQLParserOF:
					{
						p.SetState(9012)
						p.Match(PostgreSQLParserOF)
						if p.HasError() {
							// Recognition error - abort rule
							goto errorExit
						}
					}
					{
						p.SetState(9013)
						p.Match(PostgreSQLParserOPEN_PAREN)
						if p.HasError() {
							// Recognition error - abort rule
							goto errorExit
						}
					}
					{
						p.SetState(9014)
						p.Type_list()
					}
					{
						p.SetState(9015)
						p.Match(PostgreSQLParserCLOSE_PAREN)
						if p.HasError() {
							// Recognition error - abort rule
							goto errorExit
						}
					}

				case PostgreSQLParserDOCUMENT_P:
					{
						p.SetState(9017)
						p.Match(PostgreSQLParserDOCUMENT_P)
						if p.HasError() {
							// Recognition error - abort rule
							goto errorExit
						}
					}

				default:
					p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
					goto errorExit
				}

			case antlr.ATNInvalidAltNumber:
				goto errorExit
			}

		}
		p.SetState(9024)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}
		_alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 574, p.GetParserRuleContext())
		if p.HasError() {
			goto errorExit
		}
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.UnrollRecursionContexts(_parentctx)
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IC_exprContext is an interface to support dynamic dispatch.
type IC_exprContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser
	// IsC_exprContext differentiates from other interfaces.
	IsC_exprContext()
}

type C_exprContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyC_exprContext() *C_exprContext {
	var p = new(C_exprContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_c_expr
	return p
}

func InitEmptyC_exprContext(p *C_exprContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_c_expr
}

func (*C_exprContext) IsC_exprContext() {}

func NewC_exprContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *C_exprContext {
	var p = new(C_exprContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_c_expr

	return p
}

func (s *C_exprContext) GetParser() antlr.Parser { return s.parser }

func (s *C_exprContext) CopyAll(ctx *C_exprContext) {
	s.CopyFrom(&ctx.BaseParserRuleContext)
}

func (s *C_exprContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *C_exprContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

type C_expr_existsContext struct {
	C_exprContext
}

func NewC_expr_existsContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *C_expr_existsContext {
	var p = new(C_expr_existsContext)

	InitEmptyC_exprContext(&p.C_exprContext)
	p.parser = parser
	p.CopyAll(ctx.(*C_exprContext))

	return p
}

func (s *C_expr_existsContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *C_expr_existsContext) EXISTS() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserEXISTS, 0)
}

func (s *C_expr_existsContext) Select_with_parens() ISelect_with_parensContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ISelect_with_parensContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ISelect_with_parensContext)
}

func (s *C_expr_existsContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterC_expr_exists(s)
	}
}

func (s *C_expr_existsContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitC_expr_exists(s)
	}
}

func (s *C_expr_existsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitC_expr_exists(s)

	default:
		return t.VisitChildren(s)
	}
}

type C_expr_caseContext struct {
	C_exprContext
}

func NewC_expr_caseContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *C_expr_caseContext {
	var p = new(C_expr_caseContext)

	InitEmptyC_exprContext(&p.C_exprContext)
	p.parser = parser
	p.CopyAll(ctx.(*C_exprContext))

	return p
}

func (s *C_expr_caseContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *C_expr_caseContext) Case_expr() ICase_exprContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ICase_exprContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ICase_exprContext)
}

func (s *C_expr_caseContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterC_expr_case(s)
	}
}

func (s *C_expr_caseContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitC_expr_case(s)
	}
}

func (s *C_expr_caseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitC_expr_case(s)

	default:
		return t.VisitChildren(s)
	}
}

type C_expr_exprContext struct {
	C_exprContext
	a_expr_in_parens IA_exprContext
}

func NewC_expr_exprContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *C_expr_exprContext {
	var p = new(C_expr_exprContext)

	InitEmptyC_exprContext(&p.C_exprContext)
	p.parser = parser
	p.CopyAll(ctx.(*C_exprContext))

	return p
}

func (s *C_expr_exprContext) GetA_expr_in_parens() IA_exprContext { return s.a_expr_in_parens }

func (s *C_expr_exprContext) SetA_expr_in_parens(v IA_exprContext) { s.a_expr_in_parens = v }

func (s *C_expr_exprContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *C_expr_exprContext) ARRAY() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserARRAY, 0)
}

func (s *C_expr_exprContext) Select_with_parens() ISelect_with_parensContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ISelect_with_parensContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ISelect_with_parensContext)
}

func (s *C_expr_exprContext) Array_expr() IArray_exprContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IArray_exprContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IArray_exprContext)
}

func (s *C_expr_exprContext) PARAM() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserPARAM, 0)
}

func (s *C_expr_exprContext) Opt_indirection() IOpt_indirectionContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOpt_indirectionContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOpt_indirectionContext)
}

func (s *C_expr_exprContext) GROUPING() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserGROUPING, 0)
}

func (s *C_expr_exprContext) OPEN_PAREN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserOPEN_PAREN, 0)
}

func (s *C_expr_exprContext) Expr_list() IExpr_listContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IExpr_listContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IExpr_listContext)
}

func (s *C_expr_exprContext) CLOSE_PAREN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCLOSE_PAREN, 0)
}

func (s *C_expr_exprContext) UNIQUE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserUNIQUE, 0)
}

func (s *C_expr_exprContext) Columnref() IColumnrefContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IColumnrefContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IColumnrefContext)
}

func (s *C_expr_exprContext) Aexprconst() IAexprconstContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IAexprconstContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IAexprconstContext)
}

func (s *C_expr_exprContext) Plsqlvariablename() IPlsqlvariablenameContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IPlsqlvariablenameContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IPlsqlvariablenameContext)
}

func (s *C_expr_exprContext) A_expr() IA_exprContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IA_exprContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IA_exprContext)
}

func (s *C_expr_exprContext) Func_expr() IFunc_exprContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IFunc_exprContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IFunc_exprContext)
}

func (s *C_expr_exprContext) Indirection() IIndirectionContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IIndirectionContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IIndirectionContext)
}

func (s *C_expr_exprContext) Explicit_row() IExplicit_rowContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IExplicit_rowContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IExplicit_rowContext)
}

func (s *C_expr_exprContext) Implicit_row() IImplicit_rowContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IImplicit_rowContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IImplicit_rowContext)
}

func (s *C_expr_exprContext) AllRow() []IRowContext {
	children := s.GetChildren()
	len := 0
	for _, ctx := range children {
		if _, ok := ctx.(IRowContext); ok {
			len++
		}
	}

	tst := make([]IRowContext, len)
	i := 0
	for _, ctx := range children {
		if t, ok := ctx.(IRowContext); ok {
			tst[i] = t.(IRowContext)
			i++
		}
	}

	return tst
}

func (s *C_expr_exprContext) Row(i int) IRowContext {
	var t antlr.RuleContext
	j := 0
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IRowContext); ok {
			if j == i {
				t = ctx.(antlr.RuleContext)
				break
			}
			j++
		}
	}

	if t == nil {
		return nil
	}

	return t.(IRowContext)
}

func (s *C_expr_exprContext) OVERLAPS() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserOVERLAPS, 0)
}

func (s *C_expr_exprContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterC_expr_expr(s)
	}
}

func (s *C_expr_exprContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitC_expr_expr(s)
	}
}

func (s *C_expr_exprContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitC_expr_expr(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) C_expr() (localctx IC_exprContext) {
	localctx = NewC_exprContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1206, PostgreSQLParserRULE_c_expr)
	p.SetState(9061)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 577, p.GetParserRuleContext()) {
	case 1:
		localctx = NewC_expr_existsContext(p, localctx)
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(9025)
			p.Match(PostgreSQLParserEXISTS)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(9026)
			p.Select_with_parens()
		}

	case 2:
		localctx = NewC_expr_exprContext(p, localctx)
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(9027)
			p.Match(PostgreSQLParserARRAY)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		p.SetState(9030)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}

		switch p.GetTokenStream().LA(1) {
		case PostgreSQLParserOPEN_PAREN:
			{
				p.SetState(9028)
				p.Select_with_parens()
			}

		case PostgreSQLParserOPEN_BRACKET:
			{
				p.SetState(9029)
				p.Array_expr()
			}

		default:
			p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
			goto errorExit
		}

	case 3:
		localctx = NewC_expr_exprContext(p, localctx)
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(9032)
			p.Match(PostgreSQLParserPARAM)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(9033)
			p.Opt_indirection()
		}

	case 4:
		localctx = NewC_expr_exprContext(p, localctx)
		p.EnterOuterAlt(localctx, 4)
		{
			p.SetState(9034)
			p.Match(PostgreSQLParserGROUPING)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(9035)
			p.Match(PostgreSQLParserOPEN_PAREN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(9036)
			p.Expr_list()
		}
		{
			p.SetState(9037)
			p.Match(PostgreSQLParserCLOSE_PAREN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 5:
		localctx = NewC_expr_exprContext(p, localctx)
		p.EnterOuterAlt(localctx, 5)
		{
			p.SetState(9039)
			p.Match(PostgreSQLParserUNIQUE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(9040)
			p.Select_with_parens()
		}

	case 6:
		localctx = NewC_expr_exprContext(p, localctx)
		p.EnterOuterAlt(localctx, 6)
		{
			p.SetState(9041)
			p.Columnref()
		}

	case 7:
		localctx = NewC_expr_exprContext(p, localctx)
		p.EnterOuterAlt(localctx, 7)
		{
			p.SetState(9042)
			p.Aexprconst()
		}

	case 8:
		localctx = NewC_expr_exprContext(p, localctx)
		p.EnterOuterAlt(localctx, 8)
		{
			p.SetState(9043)
			p.Plsqlvariablename()
		}

	case 9:
		localctx = NewC_expr_exprContext(p, localctx)
		p.EnterOuterAlt(localctx, 9)
		{
			p.SetState(9044)
			p.Match(PostgreSQLParserOPEN_PAREN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(9045)

			var _x = p.A_expr()

			localctx.(*C_expr_exprContext).a_expr_in_parens = _x
		}
		{
			p.SetState(9046)
			p.Match(PostgreSQLParserCLOSE_PAREN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(9047)
			p.Opt_indirection()
		}

	case 10:
		localctx = NewC_expr_caseContext(p, localctx)
		p.EnterOuterAlt(localctx, 10)
		{
			p.SetState(9049)
			p.Case_expr()
		}

	case 11:
		localctx = NewC_expr_exprContext(p, localctx)
		p.EnterOuterAlt(localctx, 11)
		{
			p.SetState(9050)
			p.Func_expr()
		}

	case 12:
		localctx = NewC_expr_exprContext(p, localctx)
		p.EnterOuterAlt(localctx, 12)
		{
			p.SetState(9051)
			p.Select_with_parens()
		}
		p.SetState(9053)
		p.GetErrorHandler().Sync(p)

		if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 576, p.GetParserRuleContext()) == 1 {
			{
				p.SetState(9052)
				p.Indirection()
			}

		} else if p.HasError() { // JIM
			goto errorExit
		}

	case 13:
		localctx = NewC_expr_exprContext(p, localctx)
		p.EnterOuterAlt(localctx, 13)
		{
			p.SetState(9055)
			p.Explicit_row()
		}

	case 14:
		localctx = NewC_expr_exprContext(p, localctx)
		p.EnterOuterAlt(localctx, 14)
		{
			p.SetState(9056)
			p.Implicit_row()
		}

	case 15:
		localctx = NewC_expr_exprContext(p, localctx)
		p.EnterOuterAlt(localctx, 15)
		{
			p.SetState(9057)
			p.Row()
		}
		{
			p.SetState(9058)
			p.Match(PostgreSQLParserOVERLAPS)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(9059)
			p.Row()
		}

	case antlr.ATNInvalidAltNumber:
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IPlsqlvariablenameContext is an interface to support dynamic dispatch.
type IPlsqlvariablenameContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	PLSQLVARIABLENAME() antlr.TerminalNode

	// IsPlsqlvariablenameContext differentiates from other interfaces.
	IsPlsqlvariablenameContext()
}

type PlsqlvariablenameContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyPlsqlvariablenameContext() *PlsqlvariablenameContext {
	var p = new(PlsqlvariablenameContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_plsqlvariablename
	return p
}

func InitEmptyPlsqlvariablenameContext(p *PlsqlvariablenameContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_plsqlvariablename
}

func (*PlsqlvariablenameContext) IsPlsqlvariablenameContext() {}

func NewPlsqlvariablenameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *PlsqlvariablenameContext {
	var p = new(PlsqlvariablenameContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_plsqlvariablename

	return p
}

func (s *PlsqlvariablenameContext) GetParser() antlr.Parser { return s.parser }

func (s *PlsqlvariablenameContext) PLSQLVARIABLENAME() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserPLSQLVARIABLENAME, 0)
}

func (s *PlsqlvariablenameContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *PlsqlvariablenameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *PlsqlvariablenameContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterPlsqlvariablename(s)
	}
}

func (s *PlsqlvariablenameContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitPlsqlvariablename(s)
	}
}

func (s *PlsqlvariablenameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitPlsqlvariablename(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Plsqlvariablename() (localctx IPlsqlvariablenameContext) {
	localctx = NewPlsqlvariablenameContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1208, PostgreSQLParserRULE_plsqlvariablename)
	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(9063)
		p.Match(PostgreSQLParserPLSQLVARIABLENAME)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IFunc_applicationContext is an interface to support dynamic dispatch.
type IFunc_applicationContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Func_name() IFunc_nameContext
	OPEN_PAREN() antlr.TerminalNode
	CLOSE_PAREN() antlr.TerminalNode
	Func_arg_list() IFunc_arg_listContext
	Opt_sort_clause() IOpt_sort_clauseContext
	VARIADIC() antlr.TerminalNode
	Func_arg_expr() IFunc_arg_exprContext
	STAR() antlr.TerminalNode
	ALL() antlr.TerminalNode
	DISTINCT() antlr.TerminalNode
	COMMA() antlr.TerminalNode

	// IsFunc_applicationContext differentiates from other interfaces.
	IsFunc_applicationContext()
}

type Func_applicationContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyFunc_applicationContext() *Func_applicationContext {
	var p = new(Func_applicationContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_func_application
	return p
}

func InitEmptyFunc_applicationContext(p *Func_applicationContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_func_application
}

func (*Func_applicationContext) IsFunc_applicationContext() {}

func NewFunc_applicationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Func_applicationContext {
	var p = new(Func_applicationContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_func_application

	return p
}

func (s *Func_applicationContext) GetParser() antlr.Parser { return s.parser }

func (s *Func_applicationContext) Func_name() IFunc_nameContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IFunc_nameContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IFunc_nameContext)
}

func (s *Func_applicationContext) OPEN_PAREN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserOPEN_PAREN, 0)
}

func (s *Func_applicationContext) CLOSE_PAREN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCLOSE_PAREN, 0)
}

func (s *Func_applicationContext) Func_arg_list() IFunc_arg_listContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IFunc_arg_listContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IFunc_arg_listContext)
}

func (s *Func_applicationContext) Opt_sort_clause() IOpt_sort_clauseContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOpt_sort_clauseContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOpt_sort_clauseContext)
}

func (s *Func_applicationContext) VARIADIC() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserVARIADIC, 0)
}

func (s *Func_applicationContext) Func_arg_expr() IFunc_arg_exprContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IFunc_arg_exprContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IFunc_arg_exprContext)
}

func (s *Func_applicationContext) STAR() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserSTAR, 0)
}

func (s *Func_applicationContext) ALL() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserALL, 0)
}

func (s *Func_applicationContext) DISTINCT() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserDISTINCT, 0)
}

func (s *Func_applicationContext) COMMA() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCOMMA, 0)
}

func (s *Func_applicationContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Func_applicationContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Func_applicationContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterFunc_application(s)
	}
}

func (s *Func_applicationContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitFunc_application(s)
	}
}

func (s *Func_applicationContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitFunc_application(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Func_application() (localctx IFunc_applicationContext) {
	localctx = NewFunc_applicationContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1210, PostgreSQLParserRULE_func_application)
	var _la int

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(9065)
		p.Func_name()
	}
	{
		p.SetState(9066)
		p.Match(PostgreSQLParserOPEN_PAREN)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	p.SetState(9085)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetTokenStream().LA(1) {
	case PostgreSQLParserOPEN_PAREN, PostgreSQLParserPLUS, PostgreSQLParserMINUS, PostgreSQLParserPARAM, PostgreSQLParserOperator, PostgreSQLParserAND, PostgreSQLParserARRAY, PostgreSQLParserCASE, PostgreSQLParserCAST, PostgreSQLParserCOLLATE, PostgreSQLParserCOLUMN, PostgreSQLParserCONSTRAINT, PostgreSQLParserCURRENT_CATALOG, PostgreSQLParserCURRENT_DATE, PostgreSQLParserCURRENT_ROLE, PostgreSQLParserCURRENT_TIME, PostgreSQLParserCURRENT_TIMESTAMP, PostgreSQLParserCURRENT_USER, PostgreSQLParserDEFAULT, PostgreSQLParserDO, PostgreSQLParserFALSE_P, PostgreSQLParserFETCH, PostgreSQLParserLOCALTIME, PostgreSQLParserLOCALTIMESTAMP, PostgreSQLParserNOT, PostgreSQLParserNULL_P, PostgreSQLParserSESSION_USER, PostgreSQLParserTABLE, PostgreSQLParserTRUE_P, PostgreSQLParserUNIQUE, PostgreSQLParserUSER, PostgreSQLParserAUTHORIZATION, PostgreSQLParserBINARY, PostgreSQLParserCOLLATION, PostgreSQLParserCONCURRENTLY, PostgreSQLParserCROSS, PostgreSQLParserCURRENT_SCHEMA, PostgreSQLParserFREEZE, PostgreSQLParserFULL, PostgreSQLParserILIKE, PostgreSQLParserINNER_P, PostgreSQLParserIS, PostgreSQLParserISNULL, PostgreSQLParserJOIN, PostgreSQLParserLEFT, PostgreSQLParserLIKE, PostgreSQLParserNATURAL, PostgreSQLParserNOTNULL, PostgreSQLParserOUTER_P, PostgreSQLParserOVER, PostgreSQLParserOVERLAPS, PostgreSQLParserRIGHT, PostgreSQLParserSIMILAR, PostgreSQLParserVERBOSE, PostgreSQLParserABORT_P, PostgreSQLParserABSOLUTE_P, PostgreSQLParserACCESS, PostgreSQLParserACTION, PostgreSQLParserADD_P, PostgreSQLParserADMIN, PostgreSQLParserAFTER, PostgreSQLParserAGGREGATE, PostgreSQLParserALSO, PostgreSQLParserALTER, PostgreSQLParserALWAYS, PostgreSQLParserASSERTION, PostgreSQLParserASSIGNMENT, PostgreSQLParserAT, PostgreSQLParserATTRIBUTE, PostgreSQLParserBACKWARD, PostgreSQLParserBEFORE, PostgreSQLParserBEGIN_P, PostgreSQLParserBY, PostgreSQLParserCACHE, PostgreSQLParserCALLED, PostgreSQLParserCASCADE, PostgreSQLParserCASCADED, PostgreSQLParserCATALOG, PostgreSQLParserCHAIN, PostgreSQLParserCHARACTERISTICS, PostgreSQLParserCHECKPOINT, PostgreSQLParserCLASS, PostgreSQLParserCLOSE, PostgreSQLParserCLUSTER, PostgreSQLParserCOMMENT, PostgreSQLParserCOMMENTS, PostgreSQLParserCOMMIT, PostgreSQLParserCOMMITTED, PostgreSQLParserCONFIGURATION, PostgreSQLParserCONNECTION, PostgreSQLParserCONSTRAINTS, PostgreSQLParserCONTENT_P, PostgreSQLParserCONTINUE_P, PostgreSQLParserCONVERSION_P, PostgreSQLParserCOPY, PostgreSQLParserCOST, PostgreSQLParserCSV, PostgreSQLParserCURSOR, PostgreSQLParserCYCLE, PostgreSQLParserDATA_P, PostgreSQLParserDATABASE, PostgreSQLParserDAY_P, PostgreSQLParserDEALLOCATE, PostgreSQLParserDECLARE, PostgreSQLParserDEFAULTS, PostgreSQLParserDEFERRED, PostgreSQLParserDEFINER, PostgreSQLParserDELETE_P, PostgreSQLParserDELIMITER, PostgreSQLParserDELIMITERS, PostgreSQLParserDICTIONARY, PostgreSQLParserDISABLE_P, PostgreSQLParserDISCARD, PostgreSQLParserDOCUMENT_P, PostgreSQLParserDOMAIN_P, PostgreSQLParserDOUBLE_P, PostgreSQLParserDROP, PostgreSQLParserEACH, PostgreSQLParserENABLE_P, PostgreSQLParserENCODING, PostgreSQLParserENCRYPTED, PostgreSQLParserENUM_P, PostgreSQLParserESCAPE, PostgreSQLParserEVENT, PostgreSQLParserEXCLUDE, PostgreSQLParserEXCLUDING, PostgreSQLParserEXCLUSIVE, PostgreSQLParserEXECUTE, PostgreSQLParserEXPLAIN, PostgreSQLParserEXTENSION, PostgreSQLParserEXTERNAL, PostgreSQLParserFAMILY, PostgreSQLParserFIRST_P, PostgreSQLParserFOLLOWING, PostgreSQLParserFORCE, PostgreSQLParserFORWARD, PostgreSQLParserFUNCTION, PostgreSQLParserFUNCTIONS, PostgreSQLParserGLOBAL, PostgreSQLParserGRANTED, PostgreSQLParserHANDLER, PostgreSQLParserHEADER_P, PostgreSQLParserHOLD, PostgreSQLParserHOUR_P, PostgreSQLParserIDENTITY_P, PostgreSQLParserIF_P, PostgreSQLParserIMMEDIATE, PostgreSQLParserIMMUTABLE, PostgreSQLParserIMPLICIT_P, PostgreSQLParserINCLUDING, PostgreSQLParserINCREMENT, PostgreSQLParserINDEX, PostgreSQLParserINDEXES, PostgreSQLParserINHERIT, PostgreSQLParserINHERITS, PostgreSQLParserINLINE_P, PostgreSQLParserINSENSITIVE, PostgreSQLParserINSERT, PostgreSQLParserINSTEAD, PostgreSQLParserINVOKER, PostgreSQLParserISOLATION, PostgreSQLParserKEY, PostgreSQLParserLABEL, PostgreSQLParserLANGUAGE, PostgreSQLParserLARGE_P, PostgreSQLParserLAST_P, PostgreSQLParserLEAKPROOF, PostgreSQLParserLEVEL, PostgreSQLParserLISTEN, PostgreSQLParserLOAD, PostgreSQLParserLOCAL, PostgreSQLParserLOCATION, PostgreSQLParserLOCK_P, PostgreSQLParserMAPPING, PostgreSQLParserMATCH, PostgreSQLParserMATERIALIZED, PostgreSQLParserMAXVALUE, PostgreSQLParserMINUTE_P, PostgreSQLParserMINVALUE, PostgreSQLParserMODE, PostgreSQLParserMONTH_P, PostgreSQLParserMOVE, PostgreSQLParserNAME_P, PostgreSQLParserNAMES, PostgreSQLParserNEXT, PostgreSQLParserNO, PostgreSQLParserNOTHING, PostgreSQLParserNOTIFY, PostgreSQLParserNOWAIT, PostgreSQLParserNULLS_P, PostgreSQLParserOBJECT_P, PostgreSQLParserOF, PostgreSQLParserOFF, PostgreSQLParserOIDS, PostgreSQLParserOPERATOR, PostgreSQLParserOPTION, PostgreSQLParserOPTIONS, PostgreSQLParserOWNED, PostgreSQLParserOWNER, PostgreSQLParserPARSER, PostgreSQLParserPARTIAL, PostgreSQLParserPARTITION, PostgreSQLParserPASSING, PostgreSQLParserPASSWORD, PostgreSQLParserPLANS, PostgreSQLParserPRECEDING, PostgreSQLParserPREPARE, PostgreSQLParserPREPARED, PostgreSQLParserPRESERVE, PostgreSQLParserPRIOR, PostgreSQLParserPRIVILEGES, PostgreSQLParserPROCEDURAL, PostgreSQLParserPROCEDURE, PostgreSQLParserPROGRAM, PostgreSQLParserQUOTE, PostgreSQLParserRANGE, PostgreSQLParserREAD, PostgreSQLParserREASSIGN, PostgreSQLParserRECHECK, PostgreSQLParserRECURSIVE, PostgreSQLParserREF, PostgreSQLParserREFRESH, PostgreSQLParserREINDEX, PostgreSQLParserRELATIVE_P, PostgreSQLParserRELEASE, PostgreSQLParserRENAME, PostgreSQLParserREPEATABLE, PostgreSQLParserREPLACE, PostgreSQLParserREPLICA, PostgreSQLParserRESET, PostgreSQLParserRESTART, PostgreSQLParserRESTRICT, PostgreSQLParserRETURNS, PostgreSQLParserREVOKE, PostgreSQLParserROLE, PostgreSQLParserROLLBACK, PostgreSQLParserROWS, PostgreSQLParserRULE, PostgreSQLParserSAVEPOINT, PostgreSQLParserSCHEMA, PostgreSQLParserSCROLL, PostgreSQLParserSEARCH, PostgreSQLParserSECOND_P, PostgreSQLParserSECURITY, PostgreSQLParserSEQUENCE, PostgreSQLParserSEQUENCES, PostgreSQLParserSERIALIZABLE, PostgreSQLParserSERVER, PostgreSQLParserSESSION, PostgreSQLParserSET, PostgreSQLParserSHARE, PostgreSQLParserSHOW, PostgreSQLParserSIMPLE, PostgreSQLParserSNAPSHOT, PostgreSQLParserSTABLE, PostgreSQLParserSTANDALONE_P, PostgreSQLParserSTART, PostgreSQLParserSTATEMENT, PostgreSQLParserSTATISTICS, PostgreSQLParserSTDIN, PostgreSQLParserSTDOUT, PostgreSQLParserSTORAGE, PostgreSQLParserSTRICT_P, PostgreSQLParserSTRIP_P, PostgreSQLParserSYSID, PostgreSQLParserSYSTEM_P, PostgreSQLParserTABLES, PostgreSQLParserTABLESPACE, PostgreSQLParserTEMP, PostgreSQLParserTEMPLATE, PostgreSQLParserTEMPORARY, PostgreSQLParserTEXT_P, PostgreSQLParserTRANSACTION, PostgreSQLParserTRIGGER, PostgreSQLParserTRUNCATE, PostgreSQLParserTRUSTED, PostgreSQLParserTYPE_P, PostgreSQLParserTYPES_P, PostgreSQLParserUNBOUNDED, PostgreSQLParserUNCOMMITTED, PostgreSQLParserUNENCRYPTED, PostgreSQLParserUNKNOWN, PostgreSQLParserUNLISTEN, PostgreSQLParserUNLOGGED, PostgreSQLParserUNTIL, PostgreSQLParserUPDATE, PostgreSQLParserVACUUM, PostgreSQLParserVALID, PostgreSQLParserVALIDATE, PostgreSQLParserVALIDATOR, PostgreSQLParserVARYING, PostgreSQLParserVERSION_P, PostgreSQLParserVIEW, PostgreSQLParserVOLATILE, PostgreSQLParserWHITESPACE_P, PostgreSQLParserWITHOUT, PostgreSQLParserWORK, PostgreSQLParserWRAPPER, PostgreSQLParserWRITE, PostgreSQLParserXML_P, PostgreSQLParserYEAR_P, PostgreSQLParserYES_P, PostgreSQLParserZONE, PostgreSQLParserBETWEEN, PostgreSQLParserBIGINT, PostgreSQLParserBIT, PostgreSQLParserBOOLEAN_P, PostgreSQLParserCHAR_P, PostgreSQLParserCHARACTER, PostgreSQLParserCOALESCE, PostgreSQLParserDEC, PostgreSQLParserDECIMAL_P, PostgreSQLParserEXISTS, PostgreSQLParserEXTRACT, PostgreSQLParserFLOAT_P, PostgreSQLParserGREATEST, PostgreSQLParserINOUT, PostgreSQLParserINT_P, PostgreSQLParserINTEGER, PostgreSQLParserINTERVAL, PostgreSQLParserLEAST, PostgreSQLParserNATIONAL, PostgreSQLParserNCHAR, PostgreSQLParserNONE, PostgreSQLParserNULLIF, PostgreSQLParserNUMERIC, PostgreSQLParserOVERLAY, PostgreSQLParserPOSITION, PostgreSQLParserPRECISION, PostgreSQLParserREAL, PostgreSQLParserROW, PostgreSQLParserSETOF, PostgreSQLParserSMALLINT, PostgreSQLParserSUBSTRING, PostgreSQLParserTIME, PostgreSQLParserTIMESTAMP, PostgreSQLParserTREAT, PostgreSQLParserTRIM, PostgreSQLParserVALUES, PostgreSQLParserVARCHAR, PostgreSQLParserXMLATTRIBUTES, PostgreSQLParserXMLCOMMENT, PostgreSQLParserXMLAGG, PostgreSQLParserXML_IS_WELL_FORMED, PostgreSQLParserXML_IS_WELL_FORMED_DOCUMENT, PostgreSQLParserXML_IS_WELL_FORMED_CONTENT, PostgreSQLParserXPATH, PostgreSQLParserXPATH_EXISTS, PostgreSQLParserXMLCONCAT, PostgreSQLParserXMLELEMENT, PostgreSQLParserXMLEXISTS, PostgreSQLParserXMLFOREST, PostgreSQLParserXMLPARSE, PostgreSQLParserXMLPI, PostgreSQLParserXMLROOT, PostgreSQLParserXMLSERIALIZE, PostgreSQLParserCALL, PostgreSQLParserCURRENT_P, PostgreSQLParserATTACH, PostgreSQLParserDETACH, PostgreSQLParserEXPRESSION, PostgreSQLParserGENERATED, PostgreSQLParserLOGGED, PostgreSQLParserSTORED, PostgreSQLParserINCLUDE, PostgreSQLParserROUTINE, PostgreSQLParserTRANSFORM, PostgreSQLParserIMPORT_P, PostgreSQLParserPOLICY, PostgreSQLParserMETHOD, PostgreSQLParserREFERENCING, PostgreSQLParserNEW, PostgreSQLParserOLD, PostgreSQLParserVALUE_P, PostgreSQLParserSUBSCRIPTION, PostgreSQLParserPUBLICATION, PostgreSQLParserOUT_P, PostgreSQLParserROUTINES, PostgreSQLParserSCHEMAS, PostgreSQLParserPROCEDURES, PostgreSQLParserINPUT_P, PostgreSQLParserSUPPORT, PostgreSQLParserPARALLEL, PostgreSQLParserSQL_P, PostgreSQLParserDEPENDS, PostgreSQLParserOVERRIDING, PostgreSQLParserCONFLICT, PostgreSQLParserSKIP_P, PostgreSQLParserLOCKED, PostgreSQLParserTIES, PostgreSQLParserROLLUP, PostgreSQLParserCUBE, PostgreSQLParserGROUPING, PostgreSQLParserSETS, PostgreSQLParserTABLESAMPLE, PostgreSQLParserORDINALITY, PostgreSQLParserXMLTABLE, PostgreSQLParserCOLUMNS, PostgreSQLParserXMLNAMESPACES, PostgreSQLParserROWTYPE, PostgreSQLParserNORMALIZED, PostgreSQLParserWITHIN, PostgreSQLParserFILTER, PostgreSQLParserGROUPS, PostgreSQLParserOTHERS, PostgreSQLParserNFC, PostgreSQLParserNFD, PostgreSQLParserNFKC, PostgreSQLParserNFKD, PostgreSQLParserUESCAPE, PostgreSQLParserVIEWS, PostgreSQLParserNORMALIZE, PostgreSQLParserDUMP, PostgreSQLParserPRINT_STRICT_PARAMS, PostgreSQLParserVARIABLE_CONFLICT, PostgreSQLParserERROR, PostgreSQLParserUSE_VARIABLE, PostgreSQLParserUSE_COLUMN, PostgreSQLParserALIAS, PostgreSQLParserCONSTANT, PostgreSQLParserPERFORM, PostgreSQLParserGET, PostgreSQLParserDIAGNOSTICS, PostgreSQLParserSTACKED, PostgreSQLParserELSIF, PostgreSQLParserREVERSE, PostgreSQLParserSLICE, PostgreSQLParserEXIT, PostgreSQLParserRETURN, PostgreSQLParserQUERY, PostgreSQLParserRAISE, PostgreSQLParserSQLSTATE, PostgreSQLParserDEBUG, PostgreSQLParserLOG, PostgreSQLParserINFO, PostgreSQLParserNOTICE, PostgreSQLParserWARNING, PostgreSQLParserEXCEPTION, PostgreSQLParserASSERT, PostgreSQLParserOPEN, PostgreSQLParserABS, PostgreSQLParserCBRT, PostgreSQLParserCEIL, PostgreSQLParserCEILING, PostgreSQLParserDEGREES, PostgreSQLParserDIV, PostgreSQLParserEXP, PostgreSQLParserFACTORIAL, PostgreSQLParserFLOOR, PostgreSQLParserGCD, PostgreSQLParserLCM, PostgreSQLParserLN, PostgreSQLParserLOG10, PostgreSQLParserMIN_SCALE, PostgreSQLParserMOD, PostgreSQLParserPI, PostgreSQLParserPOWER, PostgreSQLParserRADIANS, PostgreSQLParserROUND, PostgreSQLParserSCALE, PostgreSQLParserSIGN, PostgreSQLParserSQRT, PostgreSQLParserTRIM_SCALE, PostgreSQLParserTRUNC, PostgreSQLParserWIDTH_BUCKET, PostgreSQLParserRANDOM, PostgreSQLParserSETSEED, PostgreSQLParserACOS, PostgreSQLParserACOSD, PostgreSQLParserASIN, PostgreSQLParserASIND, PostgreSQLParserATAN, PostgreSQLParserATAND, PostgreSQLParserATAN2, PostgreSQLParserATAN2D, PostgreSQLParserCOS, PostgreSQLParserCOSD, PostgreSQLParserCOT, PostgreSQLParserCOTD, PostgreSQLParserSIN, PostgreSQLParserSIND, PostgreSQLParserTAN, PostgreSQLParserTAND, PostgreSQLParserSINH, PostgreSQLParserCOSH, PostgreSQLParserTANH, PostgreSQLParserASINH, PostgreSQLParserACOSH, PostgreSQLParserATANH, PostgreSQLParserBIT_LENGTH, PostgreSQLParserCHAR_LENGTH, PostgreSQLParserCHARACTER_LENGTH, PostgreSQLParserLOWER, PostgreSQLParserOCTET_LENGTH, PostgreSQLParserUPPER, PostgreSQLParserASCII, PostgreSQLParserBTRIM, PostgreSQLParserCHR, PostgreSQLParserCONCAT, PostgreSQLParserCONCAT_WS, PostgreSQLParserFORMAT, PostgreSQLParserINITCAP, PostgreSQLParserLENGTH, PostgreSQLParserLPAD, PostgreSQLParserLTRIM, PostgreSQLParserMD5, PostgreSQLParserPARSE_IDENT, PostgreSQLParserPG_CLIENT_ENCODING, PostgreSQLParserQUOTE_IDENT, PostgreSQLParserQUOTE_LITERAL, PostgreSQLParserQUOTE_NULLABLE, PostgreSQLParserREGEXP_COUNT, PostgreSQLParserREGEXP_INSTR, PostgreSQLParserREGEXP_LIKE, PostgreSQLParserREGEXP_MATCH, PostgreSQLParserREGEXP_MATCHES, PostgreSQLParserREGEXP_REPLACE, PostgreSQLParserREGEXP_SPLIT_TO_ARRAY, PostgreSQLParserREGEXP_SPLIT_TO_TABLE, PostgreSQLParserREGEXP_SUBSTR, PostgreSQLParserREPEAT, PostgreSQLParserRPAD, PostgreSQLParserRTRIM, PostgreSQLParserSPLIT_PART, PostgreSQLParserSTARTS_WITH, PostgreSQLParserSTRING_TO_ARRAY, PostgreSQLParserSTRING_TO_TABLE, PostgreSQLParserSTRPOS, PostgreSQLParserSUBSTR, PostgreSQLParserTO_ASCII, PostgreSQLParserTO_HEX, PostgreSQLParserTRANSLATE, PostgreSQLParserUNISTR, PostgreSQLParserAGE, PostgreSQLParserCLOCK_TIMESTAMP, PostgreSQLParserDATE_BIN, PostgreSQLParserDATE_PART, PostgreSQLParserDATE_TRUNC, PostgreSQLParserISFINITE, PostgreSQLParserJUSTIFY_DAYS, PostgreSQLParserJUSTIFY_HOURS, PostgreSQLParserJUSTIFY_INTERVAL, PostgreSQLParserMAKE_DATE, PostgreSQLParserMAKE_INTERVAL, PostgreSQLParserMAKE_TIME, PostgreSQLParserMAKE_TIMESTAMP, PostgreSQLParserMAKE_TIMESTAMPTZ, PostgreSQLParserNOW, PostgreSQLParserSTATEMENT_TIMESTAMP, PostgreSQLParserTIMEOFDAY, PostgreSQLParserTRANSACTION_TIMESTAMP, PostgreSQLParserTO_TIMESTAMP, PostgreSQLParserTO_CHAR, PostgreSQLParserTO_DATE, PostgreSQLParserTO_NUMBER, PostgreSQLParserIdentifier, PostgreSQLParserQuotedIdentifier, PostgreSQLParserUnicodeQuotedIdentifier, PostgreSQLParserStringConstant, PostgreSQLParserUnicodeEscapeStringConstant, PostgreSQLParserBeginDollarStringConstant, PostgreSQLParserBinaryStringConstant, PostgreSQLParserHexadecimalStringConstant, PostgreSQLParserIntegral, PostgreSQLParserNumeric, PostgreSQLParserPLSQLVARIABLENAME, PostgreSQLParserPLSQLIDENTIFIER, PostgreSQLParserEscapeStringConstant:
		{
			p.SetState(9067)
			p.Func_arg_list()
		}
		p.SetState(9071)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}
		_la = p.GetTokenStream().LA(1)

		if _la == PostgreSQLParserCOMMA {
			{
				p.SetState(9068)
				p.Match(PostgreSQLParserCOMMA)
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}
			{
				p.SetState(9069)
				p.Match(PostgreSQLParserVARIADIC)
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}
			{
				p.SetState(9070)
				p.Func_arg_expr()
			}

		}
		{
			p.SetState(9073)
			p.Opt_sort_clause()
		}

	case PostgreSQLParserVARIADIC:
		{
			p.SetState(9075)
			p.Match(PostgreSQLParserVARIADIC)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(9076)
			p.Func_arg_expr()
		}
		{
			p.SetState(9077)
			p.Opt_sort_clause()
		}

	case PostgreSQLParserALL, PostgreSQLParserDISTINCT:
		{
			p.SetState(9079)
			_la = p.GetTokenStream().LA(1)

			if !(_la == PostgreSQLParserALL || _la == PostgreSQLParserDISTINCT) {
				p.GetErrorHandler().RecoverInline(p)
			} else {
				p.GetErrorHandler().ReportMatch(p)
				p.Consume()
			}
		}
		{
			p.SetState(9080)
			p.Func_arg_list()
		}
		{
			p.SetState(9081)
			p.Opt_sort_clause()
		}

	case PostgreSQLParserSTAR:
		{
			p.SetState(9083)
			p.Match(PostgreSQLParserSTAR)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case PostgreSQLParserCLOSE_PAREN:

	default:
		p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		goto errorExit
	}
	{
		p.SetState(9087)
		p.Match(PostgreSQLParserCLOSE_PAREN)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IFunc_exprContext is an interface to support dynamic dispatch.
type IFunc_exprContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Func_application() IFunc_applicationContext
	Within_group_clause() IWithin_group_clauseContext
	Filter_clause() IFilter_clauseContext
	Over_clause() IOver_clauseContext
	Func_expr_common_subexpr() IFunc_expr_common_subexprContext

	// IsFunc_exprContext differentiates from other interfaces.
	IsFunc_exprContext()
}

type Func_exprContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyFunc_exprContext() *Func_exprContext {
	var p = new(Func_exprContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_func_expr
	return p
}

func InitEmptyFunc_exprContext(p *Func_exprContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_func_expr
}

func (*Func_exprContext) IsFunc_exprContext() {}

func NewFunc_exprContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Func_exprContext {
	var p = new(Func_exprContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_func_expr

	return p
}

func (s *Func_exprContext) GetParser() antlr.Parser { return s.parser }

func (s *Func_exprContext) Func_application() IFunc_applicationContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IFunc_applicationContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IFunc_applicationContext)
}

func (s *Func_exprContext) Within_group_clause() IWithin_group_clauseContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IWithin_group_clauseContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IWithin_group_clauseContext)
}

func (s *Func_exprContext) Filter_clause() IFilter_clauseContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IFilter_clauseContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IFilter_clauseContext)
}

func (s *Func_exprContext) Over_clause() IOver_clauseContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOver_clauseContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOver_clauseContext)
}

func (s *Func_exprContext) Func_expr_common_subexpr() IFunc_expr_common_subexprContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IFunc_expr_common_subexprContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IFunc_expr_common_subexprContext)
}

func (s *Func_exprContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Func_exprContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Func_exprContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterFunc_expr(s)
	}
}

func (s *Func_exprContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitFunc_expr(s)
	}
}

func (s *Func_exprContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitFunc_expr(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Func_expr() (localctx IFunc_exprContext) {
	localctx = NewFunc_exprContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1212, PostgreSQLParserRULE_func_expr)
	p.SetState(9095)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 580, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(9089)
			p.Func_application()
		}
		{
			p.SetState(9090)
			p.Within_group_clause()
		}
		{
			p.SetState(9091)
			p.Filter_clause()
		}
		{
			p.SetState(9092)
			p.Over_clause()
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(9094)
			p.Func_expr_common_subexpr()
		}

	case antlr.ATNInvalidAltNumber:
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IFunc_expr_windowlessContext is an interface to support dynamic dispatch.
type IFunc_expr_windowlessContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Func_application() IFunc_applicationContext
	Func_expr_common_subexpr() IFunc_expr_common_subexprContext

	// IsFunc_expr_windowlessContext differentiates from other interfaces.
	IsFunc_expr_windowlessContext()
}

type Func_expr_windowlessContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyFunc_expr_windowlessContext() *Func_expr_windowlessContext {
	var p = new(Func_expr_windowlessContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_func_expr_windowless
	return p
}

func InitEmptyFunc_expr_windowlessContext(p *Func_expr_windowlessContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_func_expr_windowless
}

func (*Func_expr_windowlessContext) IsFunc_expr_windowlessContext() {}

func NewFunc_expr_windowlessContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Func_expr_windowlessContext {
	var p = new(Func_expr_windowlessContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_func_expr_windowless

	return p
}

func (s *Func_expr_windowlessContext) GetParser() antlr.Parser { return s.parser }

func (s *Func_expr_windowlessContext) Func_application() IFunc_applicationContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IFunc_applicationContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IFunc_applicationContext)
}

func (s *Func_expr_windowlessContext) Func_expr_common_subexpr() IFunc_expr_common_subexprContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IFunc_expr_common_subexprContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IFunc_expr_common_subexprContext)
}

func (s *Func_expr_windowlessContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Func_expr_windowlessContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Func_expr_windowlessContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterFunc_expr_windowless(s)
	}
}

func (s *Func_expr_windowlessContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitFunc_expr_windowless(s)
	}
}

func (s *Func_expr_windowlessContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitFunc_expr_windowless(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Func_expr_windowless() (localctx IFunc_expr_windowlessContext) {
	localctx = NewFunc_expr_windowlessContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1214, PostgreSQLParserRULE_func_expr_windowless)
	p.SetState(9099)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 581, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(9097)
			p.Func_application()
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(9098)
			p.Func_expr_common_subexpr()
		}

	case antlr.ATNInvalidAltNumber:
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IFunc_expr_common_subexprContext is an interface to support dynamic dispatch.
type IFunc_expr_common_subexprContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	COLLATION() antlr.TerminalNode
	FOR() antlr.TerminalNode
	OPEN_PAREN() antlr.TerminalNode
	AllA_expr() []IA_exprContext
	A_expr(i int) IA_exprContext
	CLOSE_PAREN() antlr.TerminalNode
	CURRENT_DATE() antlr.TerminalNode
	CURRENT_TIME() antlr.TerminalNode
	Iconst() IIconstContext
	CURRENT_TIMESTAMP() antlr.TerminalNode
	LOCALTIME() antlr.TerminalNode
	LOCALTIMESTAMP() antlr.TerminalNode
	CURRENT_ROLE() antlr.TerminalNode
	CURRENT_USER() antlr.TerminalNode
	SESSION_USER() antlr.TerminalNode
	USER() antlr.TerminalNode
	CURRENT_CATALOG() antlr.TerminalNode
	CURRENT_SCHEMA() antlr.TerminalNode
	CAST() antlr.TerminalNode
	AS() antlr.TerminalNode
	Typename() ITypenameContext
	EXTRACT() antlr.TerminalNode
	Extract_list() IExtract_listContext
	NORMALIZE() antlr.TerminalNode
	COMMA() antlr.TerminalNode
	Unicode_normal_form() IUnicode_normal_formContext
	OVERLAY() antlr.TerminalNode
	Overlay_list() IOverlay_listContext
	POSITION() antlr.TerminalNode
	Position_list() IPosition_listContext
	SUBSTRING() antlr.TerminalNode
	Substr_list() ISubstr_listContext
	TREAT() antlr.TerminalNode
	TRIM() antlr.TerminalNode
	Trim_list() ITrim_listContext
	BOTH() antlr.TerminalNode
	LEADING() antlr.TerminalNode
	TRAILING() antlr.TerminalNode
	NULLIF() antlr.TerminalNode
	COALESCE() antlr.TerminalNode
	Expr_list() IExpr_listContext
	GREATEST() antlr.TerminalNode
	LEAST() antlr.TerminalNode
	XMLCONCAT() antlr.TerminalNode
	XMLELEMENT() antlr.TerminalNode
	NAME_P() antlr.TerminalNode
	Collabel() ICollabelContext
	Xml_attributes() IXml_attributesContext
	XMLEXISTS() antlr.TerminalNode
	C_expr() IC_exprContext
	Xmlexists_argument() IXmlexists_argumentContext
	XMLFOREST() antlr.TerminalNode
	Xml_attribute_list() IXml_attribute_listContext
	XMLPARSE() antlr.TerminalNode
	Document_or_content() IDocument_or_contentContext
	Xml_whitespace_option() IXml_whitespace_optionContext
	XMLPI() antlr.TerminalNode
	XMLROOT() antlr.TerminalNode
	XML_P() antlr.TerminalNode
	Xml_root_version() IXml_root_versionContext
	Opt_xml_root_standalone() IOpt_xml_root_standaloneContext
	XMLSERIALIZE() antlr.TerminalNode
	Simpletypename() ISimpletypenameContext

	// IsFunc_expr_common_subexprContext differentiates from other interfaces.
	IsFunc_expr_common_subexprContext()
}

type Func_expr_common_subexprContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyFunc_expr_common_subexprContext() *Func_expr_common_subexprContext {
	var p = new(Func_expr_common_subexprContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_func_expr_common_subexpr
	return p
}

func InitEmptyFunc_expr_common_subexprContext(p *Func_expr_common_subexprContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_func_expr_common_subexpr
}

func (*Func_expr_common_subexprContext) IsFunc_expr_common_subexprContext() {}

func NewFunc_expr_common_subexprContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Func_expr_common_subexprContext {
	var p = new(Func_expr_common_subexprContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_func_expr_common_subexpr

	return p
}

func (s *Func_expr_common_subexprContext) GetParser() antlr.Parser { return s.parser }

func (s *Func_expr_common_subexprContext) COLLATION() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCOLLATION, 0)
}

func (s *Func_expr_common_subexprContext) FOR() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserFOR, 0)
}

func (s *Func_expr_common_subexprContext) OPEN_PAREN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserOPEN_PAREN, 0)
}

func (s *Func_expr_common_subexprContext) AllA_expr() []IA_exprContext {
	children := s.GetChildren()
	len := 0
	for _, ctx := range children {
		if _, ok := ctx.(IA_exprContext); ok {
			len++
		}
	}

	tst := make([]IA_exprContext, len)
	i := 0
	for _, ctx := range children {
		if t, ok := ctx.(IA_exprContext); ok {
			tst[i] = t.(IA_exprContext)
			i++
		}
	}

	return tst
}

func (s *Func_expr_common_subexprContext) A_expr(i int) IA_exprContext {
	var t antlr.RuleContext
	j := 0
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IA_exprContext); ok {
			if j == i {
				t = ctx.(antlr.RuleContext)
				break
			}
			j++
		}
	}

	if t == nil {
		return nil
	}

	return t.(IA_exprContext)
}

func (s *Func_expr_common_subexprContext) CLOSE_PAREN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCLOSE_PAREN, 0)
}

func (s *Func_expr_common_subexprContext) CURRENT_DATE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCURRENT_DATE, 0)
}

func (s *Func_expr_common_subexprContext) CURRENT_TIME() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCURRENT_TIME, 0)
}

func (s *Func_expr_common_subexprContext) Iconst() IIconstContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IIconstContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IIconstContext)
}

func (s *Func_expr_common_subexprContext) CURRENT_TIMESTAMP() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCURRENT_TIMESTAMP, 0)
}

func (s *Func_expr_common_subexprContext) LOCALTIME() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserLOCALTIME, 0)
}

func (s *Func_expr_common_subexprContext) LOCALTIMESTAMP() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserLOCALTIMESTAMP, 0)
}

func (s *Func_expr_common_subexprContext) CURRENT_ROLE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCURRENT_ROLE, 0)
}

func (s *Func_expr_common_subexprContext) CURRENT_USER() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCURRENT_USER, 0)
}

func (s *Func_expr_common_subexprContext) SESSION_USER() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserSESSION_USER, 0)
}

func (s *Func_expr_common_subexprContext) USER() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserUSER, 0)
}

func (s *Func_expr_common_subexprContext) CURRENT_CATALOG() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCURRENT_CATALOG, 0)
}

func (s *Func_expr_common_subexprContext) CURRENT_SCHEMA() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCURRENT_SCHEMA, 0)
}

func (s *Func_expr_common_subexprContext) CAST() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCAST, 0)
}

func (s *Func_expr_common_subexprContext) AS() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserAS, 0)
}

func (s *Func_expr_common_subexprContext) Typename() ITypenameContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ITypenameContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ITypenameContext)
}

func (s *Func_expr_common_subexprContext) EXTRACT() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserEXTRACT, 0)
}

func (s *Func_expr_common_subexprContext) Extract_list() IExtract_listContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IExtract_listContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IExtract_listContext)
}

func (s *Func_expr_common_subexprContext) NORMALIZE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserNORMALIZE, 0)
}

func (s *Func_expr_common_subexprContext) COMMA() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCOMMA, 0)
}

func (s *Func_expr_common_subexprContext) Unicode_normal_form() IUnicode_normal_formContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IUnicode_normal_formContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IUnicode_normal_formContext)
}

func (s *Func_expr_common_subexprContext) OVERLAY() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserOVERLAY, 0)
}

func (s *Func_expr_common_subexprContext) Overlay_list() IOverlay_listContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOverlay_listContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOverlay_listContext)
}

func (s *Func_expr_common_subexprContext) POSITION() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserPOSITION, 0)
}

func (s *Func_expr_common_subexprContext) Position_list() IPosition_listContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IPosition_listContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IPosition_listContext)
}

func (s *Func_expr_common_subexprContext) SUBSTRING() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserSUBSTRING, 0)
}

func (s *Func_expr_common_subexprContext) Substr_list() ISubstr_listContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ISubstr_listContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ISubstr_listContext)
}

func (s *Func_expr_common_subexprContext) TREAT() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserTREAT, 0)
}

func (s *Func_expr_common_subexprContext) TRIM() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserTRIM, 0)
}

func (s *Func_expr_common_subexprContext) Trim_list() ITrim_listContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ITrim_listContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ITrim_listContext)
}

func (s *Func_expr_common_subexprContext) BOTH() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserBOTH, 0)
}

func (s *Func_expr_common_subexprContext) LEADING() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserLEADING, 0)
}

func (s *Func_expr_common_subexprContext) TRAILING() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserTRAILING, 0)
}

func (s *Func_expr_common_subexprContext) NULLIF() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserNULLIF, 0)
}

func (s *Func_expr_common_subexprContext) COALESCE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCOALESCE, 0)
}

func (s *Func_expr_common_subexprContext) Expr_list() IExpr_listContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IExpr_listContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IExpr_listContext)
}

func (s *Func_expr_common_subexprContext) GREATEST() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserGREATEST, 0)
}

func (s *Func_expr_common_subexprContext) LEAST() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserLEAST, 0)
}

func (s *Func_expr_common_subexprContext) XMLCONCAT() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserXMLCONCAT, 0)
}

func (s *Func_expr_common_subexprContext) XMLELEMENT() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserXMLELEMENT, 0)
}

func (s *Func_expr_common_subexprContext) NAME_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserNAME_P, 0)
}

func (s *Func_expr_common_subexprContext) Collabel() ICollabelContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ICollabelContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ICollabelContext)
}

func (s *Func_expr_common_subexprContext) Xml_attributes() IXml_attributesContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IXml_attributesContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IXml_attributesContext)
}

func (s *Func_expr_common_subexprContext) XMLEXISTS() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserXMLEXISTS, 0)
}

func (s *Func_expr_common_subexprContext) C_expr() IC_exprContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IC_exprContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IC_exprContext)
}

func (s *Func_expr_common_subexprContext) Xmlexists_argument() IXmlexists_argumentContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IXmlexists_argumentContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IXmlexists_argumentContext)
}

func (s *Func_expr_common_subexprContext) XMLFOREST() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserXMLFOREST, 0)
}

func (s *Func_expr_common_subexprContext) Xml_attribute_list() IXml_attribute_listContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IXml_attribute_listContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IXml_attribute_listContext)
}

func (s *Func_expr_common_subexprContext) XMLPARSE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserXMLPARSE, 0)
}

func (s *Func_expr_common_subexprContext) Document_or_content() IDocument_or_contentContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IDocument_or_contentContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IDocument_or_contentContext)
}

func (s *Func_expr_common_subexprContext) Xml_whitespace_option() IXml_whitespace_optionContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IXml_whitespace_optionContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IXml_whitespace_optionContext)
}

func (s *Func_expr_common_subexprContext) XMLPI() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserXMLPI, 0)
}

func (s *Func_expr_common_subexprContext) XMLROOT() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserXMLROOT, 0)
}

func (s *Func_expr_common_subexprContext) XML_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserXML_P, 0)
}

func (s *Func_expr_common_subexprContext) Xml_root_version() IXml_root_versionContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IXml_root_versionContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IXml_root_versionContext)
}

func (s *Func_expr_common_subexprContext) Opt_xml_root_standalone() IOpt_xml_root_standaloneContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOpt_xml_root_standaloneContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOpt_xml_root_standaloneContext)
}

func (s *Func_expr_common_subexprContext) XMLSERIALIZE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserXMLSERIALIZE, 0)
}

func (s *Func_expr_common_subexprContext) Simpletypename() ISimpletypenameContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ISimpletypenameContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ISimpletypenameContext)
}

func (s *Func_expr_common_subexprContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Func_expr_common_subexprContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Func_expr_common_subexprContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterFunc_expr_common_subexpr(s)
	}
}

func (s *Func_expr_common_subexprContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitFunc_expr_common_subexpr(s)
	}
}

func (s *Func_expr_common_subexprContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitFunc_expr_common_subexpr(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Func_expr_common_subexpr() (localctx IFunc_expr_common_subexprContext) {
	localctx = NewFunc_expr_common_subexprContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1216, PostgreSQLParserRULE_func_expr_common_subexpr)
	var _la int

	p.SetState(9278)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetTokenStream().LA(1) {
	case PostgreSQLParserCOLLATION:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(9101)
			p.Match(PostgreSQLParserCOLLATION)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(9102)
			p.Match(PostgreSQLParserFOR)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(9103)
			p.Match(PostgreSQLParserOPEN_PAREN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(9104)
			p.A_expr()
		}
		{
			p.SetState(9105)
			p.Match(PostgreSQLParserCLOSE_PAREN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case PostgreSQLParserCURRENT_DATE:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(9107)
			p.Match(PostgreSQLParserCURRENT_DATE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case PostgreSQLParserCURRENT_TIME:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(9108)
			p.Match(PostgreSQLParserCURRENT_TIME)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		p.SetState(9113)
		p.GetErrorHandler().Sync(p)

		if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 582, p.GetParserRuleContext()) == 1 {
			{
				p.SetState(9109)
				p.Match(PostgreSQLParserOPEN_PAREN)
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}
			{
				p.SetState(9110)
				p.Iconst()
			}
			{
				p.SetState(9111)
				p.Match(PostgreSQLParserCLOSE_PAREN)
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}

		} else if p.HasError() { // JIM
			goto errorExit
		}

	case PostgreSQLParserCURRENT_TIMESTAMP:
		p.EnterOuterAlt(localctx, 4)
		{
			p.SetState(9115)
			p.Match(PostgreSQLParserCURRENT_TIMESTAMP)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		p.SetState(9120)
		p.GetErrorHandler().Sync(p)

		if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 583, p.GetParserRuleContext()) == 1 {
			{
				p.SetState(9116)
				p.Match(PostgreSQLParserOPEN_PAREN)
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}
			{
				p.SetState(9117)
				p.Iconst()
			}
			{
				p.SetState(9118)
				p.Match(PostgreSQLParserCLOSE_PAREN)
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}

		} else if p.HasError() { // JIM
			goto errorExit
		}

	case PostgreSQLParserLOCALTIME:
		p.EnterOuterAlt(localctx, 5)
		{
			p.SetState(9122)
			p.Match(PostgreSQLParserLOCALTIME)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		p.SetState(9127)
		p.GetErrorHandler().Sync(p)

		if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 584, p.GetParserRuleContext()) == 1 {
			{
				p.SetState(9123)
				p.Match(PostgreSQLParserOPEN_PAREN)
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}
			{
				p.SetState(9124)
				p.Iconst()
			}
			{
				p.SetState(9125)
				p.Match(PostgreSQLParserCLOSE_PAREN)
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}

		} else if p.HasError() { // JIM
			goto errorExit
		}

	case PostgreSQLParserLOCALTIMESTAMP:
		p.EnterOuterAlt(localctx, 6)
		{
			p.SetState(9129)
			p.Match(PostgreSQLParserLOCALTIMESTAMP)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		p.SetState(9134)
		p.GetErrorHandler().Sync(p)

		if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 585, p.GetParserRuleContext()) == 1 {
			{
				p.SetState(9130)
				p.Match(PostgreSQLParserOPEN_PAREN)
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}
			{
				p.SetState(9131)
				p.Iconst()
			}
			{
				p.SetState(9132)
				p.Match(PostgreSQLParserCLOSE_PAREN)
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}

		} else if p.HasError() { // JIM
			goto errorExit
		}

	case PostgreSQLParserCURRENT_ROLE:
		p.EnterOuterAlt(localctx, 7)
		{
			p.SetState(9136)
			p.Match(PostgreSQLParserCURRENT_ROLE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case PostgreSQLParserCURRENT_USER:
		p.EnterOuterAlt(localctx, 8)
		{
			p.SetState(9137)
			p.Match(PostgreSQLParserCURRENT_USER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case PostgreSQLParserSESSION_USER:
		p.EnterOuterAlt(localctx, 9)
		{
			p.SetState(9138)
			p.Match(PostgreSQLParserSESSION_USER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case PostgreSQLParserUSER:
		p.EnterOuterAlt(localctx, 10)
		{
			p.SetState(9139)
			p.Match(PostgreSQLParserUSER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case PostgreSQLParserCURRENT_CATALOG:
		p.EnterOuterAlt(localctx, 11)
		{
			p.SetState(9140)
			p.Match(PostgreSQLParserCURRENT_CATALOG)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case PostgreSQLParserCURRENT_SCHEMA:
		p.EnterOuterAlt(localctx, 12)
		{
			p.SetState(9141)
			p.Match(PostgreSQLParserCURRENT_SCHEMA)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case PostgreSQLParserCAST:
		p.EnterOuterAlt(localctx, 13)
		{
			p.SetState(9142)
			p.Match(PostgreSQLParserCAST)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(9143)
			p.Match(PostgreSQLParserOPEN_PAREN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(9144)
			p.A_expr()
		}
		{
			p.SetState(9145)
			p.Match(PostgreSQLParserAS)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(9146)
			p.Typename()
		}
		{
			p.SetState(9147)
			p.Match(PostgreSQLParserCLOSE_PAREN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case PostgreSQLParserEXTRACT:
		p.EnterOuterAlt(localctx, 14)
		{
			p.SetState(9149)
			p.Match(PostgreSQLParserEXTRACT)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(9150)
			p.Match(PostgreSQLParserOPEN_PAREN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(9151)
			p.Extract_list()
		}
		{
			p.SetState(9152)
			p.Match(PostgreSQLParserCLOSE_PAREN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case PostgreSQLParserNORMALIZE:
		p.EnterOuterAlt(localctx, 15)
		{
			p.SetState(9154)
			p.Match(PostgreSQLParserNORMALIZE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(9155)
			p.Match(PostgreSQLParserOPEN_PAREN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(9156)
			p.A_expr()
		}
		p.SetState(9159)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}
		_la = p.GetTokenStream().LA(1)

		if _la == PostgreSQLParserCOMMA {
			{
				p.SetState(9157)
				p.Match(PostgreSQLParserCOMMA)
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}
			{
				p.SetState(9158)
				p.Unicode_normal_form()
			}

		}
		{
			p.SetState(9161)
			p.Match(PostgreSQLParserCLOSE_PAREN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case PostgreSQLParserOVERLAY:
		p.EnterOuterAlt(localctx, 16)
		{
			p.SetState(9163)
			p.Match(PostgreSQLParserOVERLAY)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(9164)
			p.Match(PostgreSQLParserOPEN_PAREN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(9165)
			p.Overlay_list()
		}
		{
			p.SetState(9166)
			p.Match(PostgreSQLParserCLOSE_PAREN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case PostgreSQLParserPOSITION:
		p.EnterOuterAlt(localctx, 17)
		{
			p.SetState(9168)
			p.Match(PostgreSQLParserPOSITION)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(9169)
			p.Match(PostgreSQLParserOPEN_PAREN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(9170)
			p.Position_list()
		}
		{
			p.SetState(9171)
			p.Match(PostgreSQLParserCLOSE_PAREN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case PostgreSQLParserSUBSTRING:
		p.EnterOuterAlt(localctx, 18)
		{
			p.SetState(9173)
			p.Match(PostgreSQLParserSUBSTRING)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(9174)
			p.Match(PostgreSQLParserOPEN_PAREN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(9175)
			p.Substr_list()
		}
		{
			p.SetState(9176)
			p.Match(PostgreSQLParserCLOSE_PAREN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case PostgreSQLParserTREAT:
		p.EnterOuterAlt(localctx, 19)
		{
			p.SetState(9178)
			p.Match(PostgreSQLParserTREAT)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(9179)
			p.Match(PostgreSQLParserOPEN_PAREN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(9180)
			p.A_expr()
		}
		{
			p.SetState(9181)
			p.Match(PostgreSQLParserAS)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(9182)
			p.Typename()
		}
		{
			p.SetState(9183)
			p.Match(PostgreSQLParserCLOSE_PAREN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case PostgreSQLParserTRIM:
		p.EnterOuterAlt(localctx, 20)
		{
			p.SetState(9185)
			p.Match(PostgreSQLParserTRIM)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(9186)
			p.Match(PostgreSQLParserOPEN_PAREN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		p.SetState(9188)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}
		_la = p.GetTokenStream().LA(1)

		if (int64((_la-39)) & ^0x3f) == 0 && ((int64(1)<<(_la-39))&72057611217797121) != 0 {
			{
				p.SetState(9187)
				_la = p.GetTokenStream().LA(1)

				if !((int64((_la-39)) & ^0x3f) == 0 && ((int64(1)<<(_la-39))&72057611217797121) != 0) {
					p.GetErrorHandler().RecoverInline(p)
				} else {
					p.GetErrorHandler().ReportMatch(p)
					p.Consume()
				}
			}

		}
		{
			p.SetState(9190)
			p.Trim_list()
		}
		{
			p.SetState(9191)
			p.Match(PostgreSQLParserCLOSE_PAREN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case PostgreSQLParserNULLIF:
		p.EnterOuterAlt(localctx, 21)
		{
			p.SetState(9193)
			p.Match(PostgreSQLParserNULLIF)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(9194)
			p.Match(PostgreSQLParserOPEN_PAREN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(9195)
			p.A_expr()
		}
		{
			p.SetState(9196)
			p.Match(PostgreSQLParserCOMMA)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(9197)
			p.A_expr()
		}
		{
			p.SetState(9198)
			p.Match(PostgreSQLParserCLOSE_PAREN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case PostgreSQLParserCOALESCE:
		p.EnterOuterAlt(localctx, 22)
		{
			p.SetState(9200)
			p.Match(PostgreSQLParserCOALESCE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(9201)
			p.Match(PostgreSQLParserOPEN_PAREN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(9202)
			p.Expr_list()
		}
		{
			p.SetState(9203)
			p.Match(PostgreSQLParserCLOSE_PAREN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case PostgreSQLParserGREATEST:
		p.EnterOuterAlt(localctx, 23)
		{
			p.SetState(9205)
			p.Match(PostgreSQLParserGREATEST)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(9206)
			p.Match(PostgreSQLParserOPEN_PAREN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(9207)
			p.Expr_list()
		}
		{
			p.SetState(9208)
			p.Match(PostgreSQLParserCLOSE_PAREN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case PostgreSQLParserLEAST:
		p.EnterOuterAlt(localctx, 24)
		{
			p.SetState(9210)
			p.Match(PostgreSQLParserLEAST)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(9211)
			p.Match(PostgreSQLParserOPEN_PAREN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(9212)
			p.Expr_list()
		}
		{
			p.SetState(9213)
			p.Match(PostgreSQLParserCLOSE_PAREN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case PostgreSQLParserXMLCONCAT:
		p.EnterOuterAlt(localctx, 25)
		{
			p.SetState(9215)
			p.Match(PostgreSQLParserXMLCONCAT)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(9216)
			p.Match(PostgreSQLParserOPEN_PAREN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(9217)
			p.Expr_list()
		}
		{
			p.SetState(9218)
			p.Match(PostgreSQLParserCLOSE_PAREN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case PostgreSQLParserXMLELEMENT:
		p.EnterOuterAlt(localctx, 26)
		{
			p.SetState(9220)
			p.Match(PostgreSQLParserXMLELEMENT)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(9221)
			p.Match(PostgreSQLParserOPEN_PAREN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(9222)
			p.Match(PostgreSQLParserNAME_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(9223)
			p.Collabel()
		}
		p.SetState(9229)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}
		_la = p.GetTokenStream().LA(1)

		if _la == PostgreSQLParserCOMMA {
			{
				p.SetState(9224)
				p.Match(PostgreSQLParserCOMMA)
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}
			p.SetState(9227)
			p.GetErrorHandler().Sync(p)
			if p.HasError() {
				goto errorExit
			}

			switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 588, p.GetParserRuleContext()) {
			case 1:
				{
					p.SetState(9225)
					p.Xml_attributes()
				}

			case 2:
				{
					p.SetState(9226)
					p.Expr_list()
				}

			case antlr.ATNInvalidAltNumber:
				goto errorExit
			}

		}
		{
			p.SetState(9231)
			p.Match(PostgreSQLParserCLOSE_PAREN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case PostgreSQLParserXMLEXISTS:
		p.EnterOuterAlt(localctx, 27)
		{
			p.SetState(9233)
			p.Match(PostgreSQLParserXMLEXISTS)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(9234)
			p.Match(PostgreSQLParserOPEN_PAREN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(9235)
			p.C_expr()
		}
		{
			p.SetState(9236)
			p.Xmlexists_argument()
		}
		{
			p.SetState(9237)
			p.Match(PostgreSQLParserCLOSE_PAREN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case PostgreSQLParserXMLFOREST:
		p.EnterOuterAlt(localctx, 28)
		{
			p.SetState(9239)
			p.Match(PostgreSQLParserXMLFOREST)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(9240)
			p.Match(PostgreSQLParserOPEN_PAREN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(9241)
			p.Xml_attribute_list()
		}
		{
			p.SetState(9242)
			p.Match(PostgreSQLParserCLOSE_PAREN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case PostgreSQLParserXMLPARSE:
		p.EnterOuterAlt(localctx, 29)
		{
			p.SetState(9244)
			p.Match(PostgreSQLParserXMLPARSE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(9245)
			p.Match(PostgreSQLParserOPEN_PAREN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(9246)
			p.Document_or_content()
		}
		{
			p.SetState(9247)
			p.A_expr()
		}
		{
			p.SetState(9248)
			p.Xml_whitespace_option()
		}
		{
			p.SetState(9249)
			p.Match(PostgreSQLParserCLOSE_PAREN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case PostgreSQLParserXMLPI:
		p.EnterOuterAlt(localctx, 30)
		{
			p.SetState(9251)
			p.Match(PostgreSQLParserXMLPI)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(9252)
			p.Match(PostgreSQLParserOPEN_PAREN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(9253)
			p.Match(PostgreSQLParserNAME_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(9254)
			p.Collabel()
		}
		p.SetState(9257)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}
		_la = p.GetTokenStream().LA(1)

		if _la == PostgreSQLParserCOMMA {
			{
				p.SetState(9255)
				p.Match(PostgreSQLParserCOMMA)
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}
			{
				p.SetState(9256)
				p.A_expr()
			}

		}
		{
			p.SetState(9259)
			p.Match(PostgreSQLParserCLOSE_PAREN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case PostgreSQLParserXMLROOT:
		p.EnterOuterAlt(localctx, 31)
		{
			p.SetState(9261)
			p.Match(PostgreSQLParserXMLROOT)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(9262)
			p.Match(PostgreSQLParserOPEN_PAREN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(9263)
			p.Match(PostgreSQLParserXML_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(9264)
			p.A_expr()
		}
		{
			p.SetState(9265)
			p.Match(PostgreSQLParserCOMMA)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(9266)
			p.Xml_root_version()
		}
		{
			p.SetState(9267)
			p.Opt_xml_root_standalone()
		}
		{
			p.SetState(9268)
			p.Match(PostgreSQLParserCLOSE_PAREN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case PostgreSQLParserXMLSERIALIZE:
		p.EnterOuterAlt(localctx, 32)
		{
			p.SetState(9270)
			p.Match(PostgreSQLParserXMLSERIALIZE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(9271)
			p.Match(PostgreSQLParserOPEN_PAREN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(9272)
			p.Document_or_content()
		}
		{
			p.SetState(9273)
			p.A_expr()
		}
		{
			p.SetState(9274)
			p.Match(PostgreSQLParserAS)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(9275)
			p.Simpletypename()
		}
		{
			p.SetState(9276)
			p.Match(PostgreSQLParserCLOSE_PAREN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	default:
		p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IXml_root_versionContext is an interface to support dynamic dispatch.
type IXml_root_versionContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	VERSION_P() antlr.TerminalNode
	A_expr() IA_exprContext
	NO() antlr.TerminalNode
	VALUE_P() antlr.TerminalNode

	// IsXml_root_versionContext differentiates from other interfaces.
	IsXml_root_versionContext()
}

type Xml_root_versionContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyXml_root_versionContext() *Xml_root_versionContext {
	var p = new(Xml_root_versionContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_xml_root_version
	return p
}

func InitEmptyXml_root_versionContext(p *Xml_root_versionContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_xml_root_version
}

func (*Xml_root_versionContext) IsXml_root_versionContext() {}

func NewXml_root_versionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Xml_root_versionContext {
	var p = new(Xml_root_versionContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_xml_root_version

	return p
}

func (s *Xml_root_versionContext) GetParser() antlr.Parser { return s.parser }

func (s *Xml_root_versionContext) VERSION_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserVERSION_P, 0)
}

func (s *Xml_root_versionContext) A_expr() IA_exprContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IA_exprContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IA_exprContext)
}

func (s *Xml_root_versionContext) NO() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserNO, 0)
}

func (s *Xml_root_versionContext) VALUE_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserVALUE_P, 0)
}

func (s *Xml_root_versionContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Xml_root_versionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Xml_root_versionContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterXml_root_version(s)
	}
}

func (s *Xml_root_versionContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitXml_root_version(s)
	}
}

func (s *Xml_root_versionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitXml_root_version(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Xml_root_version() (localctx IXml_root_versionContext) {
	localctx = NewXml_root_versionContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1218, PostgreSQLParserRULE_xml_root_version)
	p.SetState(9285)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 592, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(9280)
			p.Match(PostgreSQLParserVERSION_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(9281)
			p.A_expr()
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(9282)
			p.Match(PostgreSQLParserVERSION_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(9283)
			p.Match(PostgreSQLParserNO)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(9284)
			p.Match(PostgreSQLParserVALUE_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case antlr.ATNInvalidAltNumber:
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IOpt_xml_root_standaloneContext is an interface to support dynamic dispatch.
type IOpt_xml_root_standaloneContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	COMMA() antlr.TerminalNode
	STANDALONE_P() antlr.TerminalNode
	YES_P() antlr.TerminalNode
	NO() antlr.TerminalNode
	VALUE_P() antlr.TerminalNode

	// IsOpt_xml_root_standaloneContext differentiates from other interfaces.
	IsOpt_xml_root_standaloneContext()
}

type Opt_xml_root_standaloneContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyOpt_xml_root_standaloneContext() *Opt_xml_root_standaloneContext {
	var p = new(Opt_xml_root_standaloneContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opt_xml_root_standalone
	return p
}

func InitEmptyOpt_xml_root_standaloneContext(p *Opt_xml_root_standaloneContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opt_xml_root_standalone
}

func (*Opt_xml_root_standaloneContext) IsOpt_xml_root_standaloneContext() {}

func NewOpt_xml_root_standaloneContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_xml_root_standaloneContext {
	var p = new(Opt_xml_root_standaloneContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_opt_xml_root_standalone

	return p
}

func (s *Opt_xml_root_standaloneContext) GetParser() antlr.Parser { return s.parser }

func (s *Opt_xml_root_standaloneContext) COMMA() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCOMMA, 0)
}

func (s *Opt_xml_root_standaloneContext) STANDALONE_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserSTANDALONE_P, 0)
}

func (s *Opt_xml_root_standaloneContext) YES_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserYES_P, 0)
}

func (s *Opt_xml_root_standaloneContext) NO() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserNO, 0)
}

func (s *Opt_xml_root_standaloneContext) VALUE_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserVALUE_P, 0)
}

func (s *Opt_xml_root_standaloneContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Opt_xml_root_standaloneContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Opt_xml_root_standaloneContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterOpt_xml_root_standalone(s)
	}
}

func (s *Opt_xml_root_standaloneContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitOpt_xml_root_standalone(s)
	}
}

func (s *Opt_xml_root_standaloneContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitOpt_xml_root_standalone(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Opt_xml_root_standalone() (localctx IOpt_xml_root_standaloneContext) {
	localctx = NewOpt_xml_root_standaloneContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1220, PostgreSQLParserRULE_opt_xml_root_standalone)
	p.SetState(9298)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 593, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(9287)
			p.Match(PostgreSQLParserCOMMA)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(9288)
			p.Match(PostgreSQLParserSTANDALONE_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(9289)
			p.Match(PostgreSQLParserYES_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(9290)
			p.Match(PostgreSQLParserCOMMA)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(9291)
			p.Match(PostgreSQLParserSTANDALONE_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(9292)
			p.Match(PostgreSQLParserNO)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 3:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(9293)
			p.Match(PostgreSQLParserCOMMA)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(9294)
			p.Match(PostgreSQLParserSTANDALONE_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(9295)
			p.Match(PostgreSQLParserNO)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(9296)
			p.Match(PostgreSQLParserVALUE_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 4:
		p.EnterOuterAlt(localctx, 4)

	case antlr.ATNInvalidAltNumber:
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IXml_attributesContext is an interface to support dynamic dispatch.
type IXml_attributesContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	XMLATTRIBUTES() antlr.TerminalNode
	OPEN_PAREN() antlr.TerminalNode
	Xml_attribute_list() IXml_attribute_listContext
	CLOSE_PAREN() antlr.TerminalNode

	// IsXml_attributesContext differentiates from other interfaces.
	IsXml_attributesContext()
}

type Xml_attributesContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyXml_attributesContext() *Xml_attributesContext {
	var p = new(Xml_attributesContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_xml_attributes
	return p
}

func InitEmptyXml_attributesContext(p *Xml_attributesContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_xml_attributes
}

func (*Xml_attributesContext) IsXml_attributesContext() {}

func NewXml_attributesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Xml_attributesContext {
	var p = new(Xml_attributesContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_xml_attributes

	return p
}

func (s *Xml_attributesContext) GetParser() antlr.Parser { return s.parser }

func (s *Xml_attributesContext) XMLATTRIBUTES() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserXMLATTRIBUTES, 0)
}

func (s *Xml_attributesContext) OPEN_PAREN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserOPEN_PAREN, 0)
}

func (s *Xml_attributesContext) Xml_attribute_list() IXml_attribute_listContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IXml_attribute_listContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IXml_attribute_listContext)
}

func (s *Xml_attributesContext) CLOSE_PAREN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCLOSE_PAREN, 0)
}

func (s *Xml_attributesContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Xml_attributesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Xml_attributesContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterXml_attributes(s)
	}
}

func (s *Xml_attributesContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitXml_attributes(s)
	}
}

func (s *Xml_attributesContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitXml_attributes(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Xml_attributes() (localctx IXml_attributesContext) {
	localctx = NewXml_attributesContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1222, PostgreSQLParserRULE_xml_attributes)
	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(9300)
		p.Match(PostgreSQLParserXMLATTRIBUTES)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(9301)
		p.Match(PostgreSQLParserOPEN_PAREN)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(9302)
		p.Xml_attribute_list()
	}
	{
		p.SetState(9303)
		p.Match(PostgreSQLParserCLOSE_PAREN)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IXml_attribute_listContext is an interface to support dynamic dispatch.
type IXml_attribute_listContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	AllXml_attribute_el() []IXml_attribute_elContext
	Xml_attribute_el(i int) IXml_attribute_elContext
	AllCOMMA() []antlr.TerminalNode
	COMMA(i int) antlr.TerminalNode

	// IsXml_attribute_listContext differentiates from other interfaces.
	IsXml_attribute_listContext()
}

type Xml_attribute_listContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyXml_attribute_listContext() *Xml_attribute_listContext {
	var p = new(Xml_attribute_listContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_xml_attribute_list
	return p
}

func InitEmptyXml_attribute_listContext(p *Xml_attribute_listContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_xml_attribute_list
}

func (*Xml_attribute_listContext) IsXml_attribute_listContext() {}

func NewXml_attribute_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Xml_attribute_listContext {
	var p = new(Xml_attribute_listContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_xml_attribute_list

	return p
}

func (s *Xml_attribute_listContext) GetParser() antlr.Parser { return s.parser }

func (s *Xml_attribute_listContext) AllXml_attribute_el() []IXml_attribute_elContext {
	children := s.GetChildren()
	len := 0
	for _, ctx := range children {
		if _, ok := ctx.(IXml_attribute_elContext); ok {
			len++
		}
	}

	tst := make([]IXml_attribute_elContext, len)
	i := 0
	for _, ctx := range children {
		if t, ok := ctx.(IXml_attribute_elContext); ok {
			tst[i] = t.(IXml_attribute_elContext)
			i++
		}
	}

	return tst
}

func (s *Xml_attribute_listContext) Xml_attribute_el(i int) IXml_attribute_elContext {
	var t antlr.RuleContext
	j := 0
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IXml_attribute_elContext); ok {
			if j == i {
				t = ctx.(antlr.RuleContext)
				break
			}
			j++
		}
	}

	if t == nil {
		return nil
	}

	return t.(IXml_attribute_elContext)
}

func (s *Xml_attribute_listContext) AllCOMMA() []antlr.TerminalNode {
	return s.GetTokens(PostgreSQLParserCOMMA)
}

func (s *Xml_attribute_listContext) COMMA(i int) antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCOMMA, i)
}

func (s *Xml_attribute_listContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Xml_attribute_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Xml_attribute_listContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterXml_attribute_list(s)
	}
}

func (s *Xml_attribute_listContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitXml_attribute_list(s)
	}
}

func (s *Xml_attribute_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitXml_attribute_list(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Xml_attribute_list() (localctx IXml_attribute_listContext) {
	localctx = NewXml_attribute_listContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1224, PostgreSQLParserRULE_xml_attribute_list)
	var _la int

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(9305)
		p.Xml_attribute_el()
	}
	p.SetState(9310)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}
	_la = p.GetTokenStream().LA(1)

	for _la == PostgreSQLParserCOMMA {
		{
			p.SetState(9306)
			p.Match(PostgreSQLParserCOMMA)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(9307)
			p.Xml_attribute_el()
		}

		p.SetState(9312)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}
		_la = p.GetTokenStream().LA(1)
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IXml_attribute_elContext is an interface to support dynamic dispatch.
type IXml_attribute_elContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	A_expr() IA_exprContext
	AS() antlr.TerminalNode
	Collabel() ICollabelContext

	// IsXml_attribute_elContext differentiates from other interfaces.
	IsXml_attribute_elContext()
}

type Xml_attribute_elContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyXml_attribute_elContext() *Xml_attribute_elContext {
	var p = new(Xml_attribute_elContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_xml_attribute_el
	return p
}

func InitEmptyXml_attribute_elContext(p *Xml_attribute_elContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_xml_attribute_el
}

func (*Xml_attribute_elContext) IsXml_attribute_elContext() {}

func NewXml_attribute_elContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Xml_attribute_elContext {
	var p = new(Xml_attribute_elContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_xml_attribute_el

	return p
}

func (s *Xml_attribute_elContext) GetParser() antlr.Parser { return s.parser }

func (s *Xml_attribute_elContext) A_expr() IA_exprContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IA_exprContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IA_exprContext)
}

func (s *Xml_attribute_elContext) AS() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserAS, 0)
}

func (s *Xml_attribute_elContext) Collabel() ICollabelContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ICollabelContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ICollabelContext)
}

func (s *Xml_attribute_elContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Xml_attribute_elContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Xml_attribute_elContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterXml_attribute_el(s)
	}
}

func (s *Xml_attribute_elContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitXml_attribute_el(s)
	}
}

func (s *Xml_attribute_elContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitXml_attribute_el(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Xml_attribute_el() (localctx IXml_attribute_elContext) {
	localctx = NewXml_attribute_elContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1226, PostgreSQLParserRULE_xml_attribute_el)
	var _la int

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(9313)
		p.A_expr()
	}
	p.SetState(9316)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}
	_la = p.GetTokenStream().LA(1)

	if _la == PostgreSQLParserAS {
		{
			p.SetState(9314)
			p.Match(PostgreSQLParserAS)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(9315)
			p.Collabel()
		}

	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IDocument_or_contentContext is an interface to support dynamic dispatch.
type IDocument_or_contentContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	DOCUMENT_P() antlr.TerminalNode
	CONTENT_P() antlr.TerminalNode

	// IsDocument_or_contentContext differentiates from other interfaces.
	IsDocument_or_contentContext()
}

type Document_or_contentContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyDocument_or_contentContext() *Document_or_contentContext {
	var p = new(Document_or_contentContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_document_or_content
	return p
}

func InitEmptyDocument_or_contentContext(p *Document_or_contentContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_document_or_content
}

func (*Document_or_contentContext) IsDocument_or_contentContext() {}

func NewDocument_or_contentContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Document_or_contentContext {
	var p = new(Document_or_contentContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_document_or_content

	return p
}

func (s *Document_or_contentContext) GetParser() antlr.Parser { return s.parser }

func (s *Document_or_contentContext) DOCUMENT_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserDOCUMENT_P, 0)
}

func (s *Document_or_contentContext) CONTENT_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCONTENT_P, 0)
}

func (s *Document_or_contentContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Document_or_contentContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Document_or_contentContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterDocument_or_content(s)
	}
}

func (s *Document_or_contentContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitDocument_or_content(s)
	}
}

func (s *Document_or_contentContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitDocument_or_content(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Document_or_content() (localctx IDocument_or_contentContext) {
	localctx = NewDocument_or_contentContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1228, PostgreSQLParserRULE_document_or_content)
	var _la int

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(9318)
		_la = p.GetTokenStream().LA(1)

		if !(_la == PostgreSQLParserCONTENT_P || _la == PostgreSQLParserDOCUMENT_P) {
			p.GetErrorHandler().RecoverInline(p)
		} else {
			p.GetErrorHandler().ReportMatch(p)
			p.Consume()
		}
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IXml_whitespace_optionContext is an interface to support dynamic dispatch.
type IXml_whitespace_optionContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	PRESERVE() antlr.TerminalNode
	WHITESPACE_P() antlr.TerminalNode
	STRIP_P() antlr.TerminalNode

	// IsXml_whitespace_optionContext differentiates from other interfaces.
	IsXml_whitespace_optionContext()
}

type Xml_whitespace_optionContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyXml_whitespace_optionContext() *Xml_whitespace_optionContext {
	var p = new(Xml_whitespace_optionContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_xml_whitespace_option
	return p
}

func InitEmptyXml_whitespace_optionContext(p *Xml_whitespace_optionContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_xml_whitespace_option
}

func (*Xml_whitespace_optionContext) IsXml_whitespace_optionContext() {}

func NewXml_whitespace_optionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Xml_whitespace_optionContext {
	var p = new(Xml_whitespace_optionContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_xml_whitespace_option

	return p
}

func (s *Xml_whitespace_optionContext) GetParser() antlr.Parser { return s.parser }

func (s *Xml_whitespace_optionContext) PRESERVE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserPRESERVE, 0)
}

func (s *Xml_whitespace_optionContext) WHITESPACE_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserWHITESPACE_P, 0)
}

func (s *Xml_whitespace_optionContext) STRIP_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserSTRIP_P, 0)
}

func (s *Xml_whitespace_optionContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Xml_whitespace_optionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Xml_whitespace_optionContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterXml_whitespace_option(s)
	}
}

func (s *Xml_whitespace_optionContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitXml_whitespace_option(s)
	}
}

func (s *Xml_whitespace_optionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitXml_whitespace_option(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Xml_whitespace_option() (localctx IXml_whitespace_optionContext) {
	localctx = NewXml_whitespace_optionContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1230, PostgreSQLParserRULE_xml_whitespace_option)
	p.SetState(9325)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetTokenStream().LA(1) {
	case PostgreSQLParserPRESERVE:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(9320)
			p.Match(PostgreSQLParserPRESERVE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(9321)
			p.Match(PostgreSQLParserWHITESPACE_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case PostgreSQLParserSTRIP_P:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(9322)
			p.Match(PostgreSQLParserSTRIP_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(9323)
			p.Match(PostgreSQLParserWHITESPACE_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case PostgreSQLParserCLOSE_PAREN:
		p.EnterOuterAlt(localctx, 3)

	default:
		p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IXmlexists_argumentContext is an interface to support dynamic dispatch.
type IXmlexists_argumentContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	PASSING() antlr.TerminalNode
	C_expr() IC_exprContext
	AllXml_passing_mech() []IXml_passing_mechContext
	Xml_passing_mech(i int) IXml_passing_mechContext

	// IsXmlexists_argumentContext differentiates from other interfaces.
	IsXmlexists_argumentContext()
}

type Xmlexists_argumentContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyXmlexists_argumentContext() *Xmlexists_argumentContext {
	var p = new(Xmlexists_argumentContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_xmlexists_argument
	return p
}

func InitEmptyXmlexists_argumentContext(p *Xmlexists_argumentContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_xmlexists_argument
}

func (*Xmlexists_argumentContext) IsXmlexists_argumentContext() {}

func NewXmlexists_argumentContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Xmlexists_argumentContext {
	var p = new(Xmlexists_argumentContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_xmlexists_argument

	return p
}

func (s *Xmlexists_argumentContext) GetParser() antlr.Parser { return s.parser }

func (s *Xmlexists_argumentContext) PASSING() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserPASSING, 0)
}

func (s *Xmlexists_argumentContext) C_expr() IC_exprContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IC_exprContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IC_exprContext)
}

func (s *Xmlexists_argumentContext) AllXml_passing_mech() []IXml_passing_mechContext {
	children := s.GetChildren()
	len := 0
	for _, ctx := range children {
		if _, ok := ctx.(IXml_passing_mechContext); ok {
			len++
		}
	}

	tst := make([]IXml_passing_mechContext, len)
	i := 0
	for _, ctx := range children {
		if t, ok := ctx.(IXml_passing_mechContext); ok {
			tst[i] = t.(IXml_passing_mechContext)
			i++
		}
	}

	return tst
}

func (s *Xmlexists_argumentContext) Xml_passing_mech(i int) IXml_passing_mechContext {
	var t antlr.RuleContext
	j := 0
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IXml_passing_mechContext); ok {
			if j == i {
				t = ctx.(antlr.RuleContext)
				break
			}
			j++
		}
	}

	if t == nil {
		return nil
	}

	return t.(IXml_passing_mechContext)
}

func (s *Xmlexists_argumentContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Xmlexists_argumentContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Xmlexists_argumentContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterXmlexists_argument(s)
	}
}

func (s *Xmlexists_argumentContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitXmlexists_argument(s)
	}
}

func (s *Xmlexists_argumentContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitXmlexists_argument(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Xmlexists_argument() (localctx IXmlexists_argumentContext) {
	localctx = NewXmlexists_argumentContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1232, PostgreSQLParserRULE_xmlexists_argument)
	p.SetState(9342)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 597, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(9327)
			p.Match(PostgreSQLParserPASSING)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(9328)
			p.C_expr()
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(9329)
			p.Match(PostgreSQLParserPASSING)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(9330)
			p.C_expr()
		}
		{
			p.SetState(9331)
			p.Xml_passing_mech()
		}

	case 3:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(9333)
			p.Match(PostgreSQLParserPASSING)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(9334)
			p.Xml_passing_mech()
		}
		{
			p.SetState(9335)
			p.C_expr()
		}

	case 4:
		p.EnterOuterAlt(localctx, 4)
		{
			p.SetState(9337)
			p.Match(PostgreSQLParserPASSING)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(9338)
			p.Xml_passing_mech()
		}
		{
			p.SetState(9339)
			p.C_expr()
		}
		{
			p.SetState(9340)
			p.Xml_passing_mech()
		}

	case antlr.ATNInvalidAltNumber:
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IXml_passing_mechContext is an interface to support dynamic dispatch.
type IXml_passing_mechContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	BY() antlr.TerminalNode
	REF() antlr.TerminalNode
	VALUE_P() antlr.TerminalNode

	// IsXml_passing_mechContext differentiates from other interfaces.
	IsXml_passing_mechContext()
}

type Xml_passing_mechContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyXml_passing_mechContext() *Xml_passing_mechContext {
	var p = new(Xml_passing_mechContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_xml_passing_mech
	return p
}

func InitEmptyXml_passing_mechContext(p *Xml_passing_mechContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_xml_passing_mech
}

func (*Xml_passing_mechContext) IsXml_passing_mechContext() {}

func NewXml_passing_mechContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Xml_passing_mechContext {
	var p = new(Xml_passing_mechContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_xml_passing_mech

	return p
}

func (s *Xml_passing_mechContext) GetParser() antlr.Parser { return s.parser }

func (s *Xml_passing_mechContext) BY() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserBY, 0)
}

func (s *Xml_passing_mechContext) REF() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserREF, 0)
}

func (s *Xml_passing_mechContext) VALUE_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserVALUE_P, 0)
}

func (s *Xml_passing_mechContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Xml_passing_mechContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Xml_passing_mechContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterXml_passing_mech(s)
	}
}

func (s *Xml_passing_mechContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitXml_passing_mech(s)
	}
}

func (s *Xml_passing_mechContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitXml_passing_mech(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Xml_passing_mech() (localctx IXml_passing_mechContext) {
	localctx = NewXml_passing_mechContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1234, PostgreSQLParserRULE_xml_passing_mech)
	var _la int

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(9344)
		p.Match(PostgreSQLParserBY)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(9345)
		_la = p.GetTokenStream().LA(1)

		if !(_la == PostgreSQLParserREF || _la == PostgreSQLParserVALUE_P) {
			p.GetErrorHandler().RecoverInline(p)
		} else {
			p.GetErrorHandler().ReportMatch(p)
			p.Consume()
		}
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IWithin_group_clauseContext is an interface to support dynamic dispatch.
type IWithin_group_clauseContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	WITHIN() antlr.TerminalNode
	GROUP_P() antlr.TerminalNode
	OPEN_PAREN() antlr.TerminalNode
	Sort_clause() ISort_clauseContext
	CLOSE_PAREN() antlr.TerminalNode

	// IsWithin_group_clauseContext differentiates from other interfaces.
	IsWithin_group_clauseContext()
}

type Within_group_clauseContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyWithin_group_clauseContext() *Within_group_clauseContext {
	var p = new(Within_group_clauseContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_within_group_clause
	return p
}

func InitEmptyWithin_group_clauseContext(p *Within_group_clauseContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_within_group_clause
}

func (*Within_group_clauseContext) IsWithin_group_clauseContext() {}

func NewWithin_group_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Within_group_clauseContext {
	var p = new(Within_group_clauseContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_within_group_clause

	return p
}

func (s *Within_group_clauseContext) GetParser() antlr.Parser { return s.parser }

func (s *Within_group_clauseContext) WITHIN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserWITHIN, 0)
}

func (s *Within_group_clauseContext) GROUP_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserGROUP_P, 0)
}

func (s *Within_group_clauseContext) OPEN_PAREN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserOPEN_PAREN, 0)
}

func (s *Within_group_clauseContext) Sort_clause() ISort_clauseContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ISort_clauseContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ISort_clauseContext)
}

func (s *Within_group_clauseContext) CLOSE_PAREN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCLOSE_PAREN, 0)
}

func (s *Within_group_clauseContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Within_group_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Within_group_clauseContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterWithin_group_clause(s)
	}
}

func (s *Within_group_clauseContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitWithin_group_clause(s)
	}
}

func (s *Within_group_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitWithin_group_clause(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Within_group_clause() (localctx IWithin_group_clauseContext) {
	localctx = NewWithin_group_clauseContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1236, PostgreSQLParserRULE_within_group_clause)
	p.SetState(9354)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 598, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(9347)
			p.Match(PostgreSQLParserWITHIN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(9348)
			p.Match(PostgreSQLParserGROUP_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(9349)
			p.Match(PostgreSQLParserOPEN_PAREN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(9350)
			p.Sort_clause()
		}
		{
			p.SetState(9351)
			p.Match(PostgreSQLParserCLOSE_PAREN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)

	case antlr.ATNInvalidAltNumber:
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IFilter_clauseContext is an interface to support dynamic dispatch.
type IFilter_clauseContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	FILTER() antlr.TerminalNode
	OPEN_PAREN() antlr.TerminalNode
	WHERE() antlr.TerminalNode
	A_expr() IA_exprContext
	CLOSE_PAREN() antlr.TerminalNode

	// IsFilter_clauseContext differentiates from other interfaces.
	IsFilter_clauseContext()
}

type Filter_clauseContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyFilter_clauseContext() *Filter_clauseContext {
	var p = new(Filter_clauseContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_filter_clause
	return p
}

func InitEmptyFilter_clauseContext(p *Filter_clauseContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_filter_clause
}

func (*Filter_clauseContext) IsFilter_clauseContext() {}

func NewFilter_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Filter_clauseContext {
	var p = new(Filter_clauseContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_filter_clause

	return p
}

func (s *Filter_clauseContext) GetParser() antlr.Parser { return s.parser }

func (s *Filter_clauseContext) FILTER() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserFILTER, 0)
}

func (s *Filter_clauseContext) OPEN_PAREN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserOPEN_PAREN, 0)
}

func (s *Filter_clauseContext) WHERE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserWHERE, 0)
}

func (s *Filter_clauseContext) A_expr() IA_exprContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IA_exprContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IA_exprContext)
}

func (s *Filter_clauseContext) CLOSE_PAREN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCLOSE_PAREN, 0)
}

func (s *Filter_clauseContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Filter_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Filter_clauseContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterFilter_clause(s)
	}
}

func (s *Filter_clauseContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitFilter_clause(s)
	}
}

func (s *Filter_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitFilter_clause(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Filter_clause() (localctx IFilter_clauseContext) {
	localctx = NewFilter_clauseContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1238, PostgreSQLParserRULE_filter_clause)
	p.SetState(9363)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 599, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(9356)
			p.Match(PostgreSQLParserFILTER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(9357)
			p.Match(PostgreSQLParserOPEN_PAREN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(9358)
			p.Match(PostgreSQLParserWHERE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(9359)
			p.A_expr()
		}
		{
			p.SetState(9360)
			p.Match(PostgreSQLParserCLOSE_PAREN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)

	case antlr.ATNInvalidAltNumber:
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IWindow_clauseContext is an interface to support dynamic dispatch.
type IWindow_clauseContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	WINDOW() antlr.TerminalNode
	Window_definition_list() IWindow_definition_listContext

	// IsWindow_clauseContext differentiates from other interfaces.
	IsWindow_clauseContext()
}

type Window_clauseContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyWindow_clauseContext() *Window_clauseContext {
	var p = new(Window_clauseContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_window_clause
	return p
}

func InitEmptyWindow_clauseContext(p *Window_clauseContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_window_clause
}

func (*Window_clauseContext) IsWindow_clauseContext() {}

func NewWindow_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Window_clauseContext {
	var p = new(Window_clauseContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_window_clause

	return p
}

func (s *Window_clauseContext) GetParser() antlr.Parser { return s.parser }

func (s *Window_clauseContext) WINDOW() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserWINDOW, 0)
}

func (s *Window_clauseContext) Window_definition_list() IWindow_definition_listContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IWindow_definition_listContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IWindow_definition_listContext)
}

func (s *Window_clauseContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Window_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Window_clauseContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterWindow_clause(s)
	}
}

func (s *Window_clauseContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitWindow_clause(s)
	}
}

func (s *Window_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitWindow_clause(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Window_clause() (localctx IWindow_clauseContext) {
	localctx = NewWindow_clauseContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1240, PostgreSQLParserRULE_window_clause)
	p.SetState(9368)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetTokenStream().LA(1) {
	case PostgreSQLParserWINDOW:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(9365)
			p.Match(PostgreSQLParserWINDOW)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(9366)
			p.Window_definition_list()
		}

	case PostgreSQLParserEOF, PostgreSQLParserOPEN_PAREN, PostgreSQLParserCLOSE_PAREN, PostgreSQLParserCOMMA, PostgreSQLParserSEMI, PostgreSQLParserANALYSE, PostgreSQLParserANALYZE, PostgreSQLParserCREATE, PostgreSQLParserDO, PostgreSQLParserEXCEPT, PostgreSQLParserFETCH, PostgreSQLParserFOR, PostgreSQLParserGRANT, PostgreSQLParserINTERSECT, PostgreSQLParserINTO, PostgreSQLParserLIMIT, PostgreSQLParserOFFSET, PostgreSQLParserON, PostgreSQLParserORDER, PostgreSQLParserRETURNING, PostgreSQLParserSELECT, PostgreSQLParserTABLE, PostgreSQLParserTHEN, PostgreSQLParserUNION, PostgreSQLParserUSING, PostgreSQLParserWHEN, PostgreSQLParserWITH, PostgreSQLParserABORT_P, PostgreSQLParserALTER, PostgreSQLParserBEGIN_P, PostgreSQLParserCHECKPOINT, PostgreSQLParserCLOSE, PostgreSQLParserCLUSTER, PostgreSQLParserCOMMENT, PostgreSQLParserCOMMIT, PostgreSQLParserCOPY, PostgreSQLParserDEALLOCATE, PostgreSQLParserDECLARE, PostgreSQLParserDELETE_P, PostgreSQLParserDISCARD, PostgreSQLParserDROP, PostgreSQLParserEXECUTE, PostgreSQLParserEXPLAIN, PostgreSQLParserINSERT, PostgreSQLParserLISTEN, PostgreSQLParserLOAD, PostgreSQLParserLOCK_P, PostgreSQLParserMERGE, PostgreSQLParserMOVE, PostgreSQLParserNOTIFY, PostgreSQLParserPREPARE, PostgreSQLParserREASSIGN, PostgreSQLParserREFRESH, PostgreSQLParserREINDEX, PostgreSQLParserRELEASE, PostgreSQLParserRESET, PostgreSQLParserREVOKE, PostgreSQLParserROLLBACK, PostgreSQLParserSAVEPOINT, PostgreSQLParserSECURITY, PostgreSQLParserSET, PostgreSQLParserSHOW, PostgreSQLParserSTART, PostgreSQLParserTRUNCATE, PostgreSQLParserUNLISTEN, PostgreSQLParserUPDATE, PostgreSQLParserVACUUM, PostgreSQLParserVALUES, PostgreSQLParserCALL, PostgreSQLParserIMPORT_P, PostgreSQLParserEND_P, PostgreSQLParserLOOP, PostgreSQLParserMetaCommand:
		p.EnterOuterAlt(localctx, 2)

	default:
		p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IWindow_definition_listContext is an interface to support dynamic dispatch.
type IWindow_definition_listContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	AllWindow_definition() []IWindow_definitionContext
	Window_definition(i int) IWindow_definitionContext
	AllCOMMA() []antlr.TerminalNode
	COMMA(i int) antlr.TerminalNode

	// IsWindow_definition_listContext differentiates from other interfaces.
	IsWindow_definition_listContext()
}

type Window_definition_listContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyWindow_definition_listContext() *Window_definition_listContext {
	var p = new(Window_definition_listContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_window_definition_list
	return p
}

func InitEmptyWindow_definition_listContext(p *Window_definition_listContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_window_definition_list
}

func (*Window_definition_listContext) IsWindow_definition_listContext() {}

func NewWindow_definition_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Window_definition_listContext {
	var p = new(Window_definition_listContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_window_definition_list

	return p
}

func (s *Window_definition_listContext) GetParser() antlr.Parser { return s.parser }

func (s *Window_definition_listContext) AllWindow_definition() []IWindow_definitionContext {
	children := s.GetChildren()
	len := 0
	for _, ctx := range children {
		if _, ok := ctx.(IWindow_definitionContext); ok {
			len++
		}
	}

	tst := make([]IWindow_definitionContext, len)
	i := 0
	for _, ctx := range children {
		if t, ok := ctx.(IWindow_definitionContext); ok {
			tst[i] = t.(IWindow_definitionContext)
			i++
		}
	}

	return tst
}

func (s *Window_definition_listContext) Window_definition(i int) IWindow_definitionContext {
	var t antlr.RuleContext
	j := 0
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IWindow_definitionContext); ok {
			if j == i {
				t = ctx.(antlr.RuleContext)
				break
			}
			j++
		}
	}

	if t == nil {
		return nil
	}

	return t.(IWindow_definitionContext)
}

func (s *Window_definition_listContext) AllCOMMA() []antlr.TerminalNode {
	return s.GetTokens(PostgreSQLParserCOMMA)
}

func (s *Window_definition_listContext) COMMA(i int) antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCOMMA, i)
}

func (s *Window_definition_listContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Window_definition_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Window_definition_listContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterWindow_definition_list(s)
	}
}

func (s *Window_definition_listContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitWindow_definition_list(s)
	}
}

func (s *Window_definition_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitWindow_definition_list(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Window_definition_list() (localctx IWindow_definition_listContext) {
	localctx = NewWindow_definition_listContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1242, PostgreSQLParserRULE_window_definition_list)
	var _alt int

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(9370)
		p.Window_definition()
	}
	p.SetState(9375)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}
	_alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 601, p.GetParserRuleContext())
	if p.HasError() {
		goto errorExit
	}
	for _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
		if _alt == 1 {
			{
				p.SetState(9371)
				p.Match(PostgreSQLParserCOMMA)
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}
			{
				p.SetState(9372)
				p.Window_definition()
			}

		}
		p.SetState(9377)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}
		_alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 601, p.GetParserRuleContext())
		if p.HasError() {
			goto errorExit
		}
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IWindow_definitionContext is an interface to support dynamic dispatch.
type IWindow_definitionContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Colid() IColidContext
	AS() antlr.TerminalNode
	Window_specification() IWindow_specificationContext

	// IsWindow_definitionContext differentiates from other interfaces.
	IsWindow_definitionContext()
}

type Window_definitionContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyWindow_definitionContext() *Window_definitionContext {
	var p = new(Window_definitionContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_window_definition
	return p
}

func InitEmptyWindow_definitionContext(p *Window_definitionContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_window_definition
}

func (*Window_definitionContext) IsWindow_definitionContext() {}

func NewWindow_definitionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Window_definitionContext {
	var p = new(Window_definitionContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_window_definition

	return p
}

func (s *Window_definitionContext) GetParser() antlr.Parser { return s.parser }

func (s *Window_definitionContext) Colid() IColidContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IColidContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IColidContext)
}

func (s *Window_definitionContext) AS() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserAS, 0)
}

func (s *Window_definitionContext) Window_specification() IWindow_specificationContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IWindow_specificationContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IWindow_specificationContext)
}

func (s *Window_definitionContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Window_definitionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Window_definitionContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterWindow_definition(s)
	}
}

func (s *Window_definitionContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitWindow_definition(s)
	}
}

func (s *Window_definitionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitWindow_definition(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Window_definition() (localctx IWindow_definitionContext) {
	localctx = NewWindow_definitionContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1244, PostgreSQLParserRULE_window_definition)
	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(9378)
		p.Colid()
	}
	{
		p.SetState(9379)
		p.Match(PostgreSQLParserAS)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(9380)
		p.Window_specification()
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IOver_clauseContext is an interface to support dynamic dispatch.
type IOver_clauseContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	OVER() antlr.TerminalNode
	Window_specification() IWindow_specificationContext
	Colid() IColidContext

	// IsOver_clauseContext differentiates from other interfaces.
	IsOver_clauseContext()
}

type Over_clauseContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyOver_clauseContext() *Over_clauseContext {
	var p = new(Over_clauseContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_over_clause
	return p
}

func InitEmptyOver_clauseContext(p *Over_clauseContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_over_clause
}

func (*Over_clauseContext) IsOver_clauseContext() {}

func NewOver_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Over_clauseContext {
	var p = new(Over_clauseContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_over_clause

	return p
}

func (s *Over_clauseContext) GetParser() antlr.Parser { return s.parser }

func (s *Over_clauseContext) OVER() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserOVER, 0)
}

func (s *Over_clauseContext) Window_specification() IWindow_specificationContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IWindow_specificationContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IWindow_specificationContext)
}

func (s *Over_clauseContext) Colid() IColidContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IColidContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IColidContext)
}

func (s *Over_clauseContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Over_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Over_clauseContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterOver_clause(s)
	}
}

func (s *Over_clauseContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitOver_clause(s)
	}
}

func (s *Over_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitOver_clause(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Over_clause() (localctx IOver_clauseContext) {
	localctx = NewOver_clauseContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1246, PostgreSQLParserRULE_over_clause)
	p.SetState(9388)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 603, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(9382)
			p.Match(PostgreSQLParserOVER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		p.SetState(9385)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}

		switch p.GetTokenStream().LA(1) {
		case PostgreSQLParserOPEN_PAREN:
			{
				p.SetState(9383)
				p.Window_specification()
			}

		case PostgreSQLParserAND, PostgreSQLParserARRAY, PostgreSQLParserCOLLATE, PostgreSQLParserCOLUMN, PostgreSQLParserCONSTRAINT, PostgreSQLParserDEFAULT, PostgreSQLParserDO, PostgreSQLParserFETCH, PostgreSQLParserTABLE, PostgreSQLParserIS, PostgreSQLParserLEFT, PostgreSQLParserOUTER_P, PostgreSQLParserOVER, PostgreSQLParserRIGHT, PostgreSQLParserABORT_P, PostgreSQLParserABSOLUTE_P, PostgreSQLParserACCESS, PostgreSQLParserACTION, PostgreSQLParserADD_P, PostgreSQLParserADMIN, PostgreSQLParserAFTER, PostgreSQLParserAGGREGATE, PostgreSQLParserALSO, PostgreSQLParserALTER, PostgreSQLParserALWAYS, PostgreSQLParserASSERTION, PostgreSQLParserASSIGNMENT, PostgreSQLParserAT, PostgreSQLParserATTRIBUTE, PostgreSQLParserBACKWARD, PostgreSQLParserBEFORE, PostgreSQLParserBEGIN_P, PostgreSQLParserBY, PostgreSQLParserCACHE, PostgreSQLParserCALLED, PostgreSQLParserCASCADE, PostgreSQLParserCASCADED, PostgreSQLParserCATALOG, PostgreSQLParserCHAIN, PostgreSQLParserCHARACTERISTICS, PostgreSQLParserCHECKPOINT, PostgreSQLParserCLASS, PostgreSQLParserCLOSE, PostgreSQLParserCLUSTER, PostgreSQLParserCOMMENT, PostgreSQLParserCOMMENTS, PostgreSQLParserCOMMIT, PostgreSQLParserCOMMITTED, PostgreSQLParserCONFIGURATION, PostgreSQLParserCONNECTION, PostgreSQLParserCONSTRAINTS, PostgreSQLParserCONTENT_P, PostgreSQLParserCONTINUE_P, PostgreSQLParserCONVERSION_P, PostgreSQLParserCOPY, PostgreSQLParserCOST, PostgreSQLParserCSV, PostgreSQLParserCURSOR, PostgreSQLParserCYCLE, PostgreSQLParserDATA_P, PostgreSQLParserDATABASE, PostgreSQLParserDAY_P, PostgreSQLParserDEALLOCATE, PostgreSQLParserDECLARE, PostgreSQLParserDEFAULTS, PostgreSQLParserDEFERRED, PostgreSQLParserDEFINER, PostgreSQLParserDELETE_P, PostgreSQLParserDELIMITER, PostgreSQLParserDELIMITERS, PostgreSQLParserDICTIONARY, PostgreSQLParserDISABLE_P, PostgreSQLParserDISCARD, PostgreSQLParserDOCUMENT_P, PostgreSQLParserDOMAIN_P, PostgreSQLParserDOUBLE_P, PostgreSQLParserDROP, PostgreSQLParserEACH, PostgreSQLParserENABLE_P, PostgreSQLParserENCODING, PostgreSQLParserENCRYPTED, PostgreSQLParserENUM_P, PostgreSQLParserESCAPE, PostgreSQLParserEVENT, PostgreSQLParserEXCLUDE, PostgreSQLParserEXCLUDING, PostgreSQLParserEXCLUSIVE, PostgreSQLParserEXECUTE, PostgreSQLParserEXPLAIN, PostgreSQLParserEXTENSION, PostgreSQLParserEXTERNAL, PostgreSQLParserFAMILY, PostgreSQLParserFIRST_P, PostgreSQLParserFOLLOWING, PostgreSQLParserFORCE, PostgreSQLParserFORWARD, PostgreSQLParserFUNCTION, PostgreSQLParserFUNCTIONS, PostgreSQLParserGLOBAL, PostgreSQLParserGRANTED, PostgreSQLParserHANDLER, PostgreSQLParserHEADER_P, PostgreSQLParserHOLD, PostgreSQLParserHOUR_P, PostgreSQLParserIDENTITY_P, PostgreSQLParserIF_P, PostgreSQLParserIMMEDIATE, PostgreSQLParserIMMUTABLE, PostgreSQLParserIMPLICIT_P, PostgreSQLParserINCLUDING, PostgreSQLParserINCREMENT, PostgreSQLParserINDEX, PostgreSQLParserINDEXES, PostgreSQLParserINHERIT, PostgreSQLParserINHERITS, PostgreSQLParserINLINE_P, PostgreSQLParserINSENSITIVE, PostgreSQLParserINSERT, PostgreSQLParserINSTEAD, PostgreSQLParserINVOKER, PostgreSQLParserISOLATION, PostgreSQLParserKEY, PostgreSQLParserLABEL, PostgreSQLParserLANGUAGE, PostgreSQLParserLARGE_P, PostgreSQLParserLAST_P, PostgreSQLParserLEAKPROOF, PostgreSQLParserLEVEL, PostgreSQLParserLISTEN, PostgreSQLParserLOAD, PostgreSQLParserLOCAL, PostgreSQLParserLOCATION, PostgreSQLParserLOCK_P, PostgreSQLParserMAPPING, PostgreSQLParserMATCH, PostgreSQLParserMATERIALIZED, PostgreSQLParserMAXVALUE, PostgreSQLParserMINUTE_P, PostgreSQLParserMINVALUE, PostgreSQLParserMODE, PostgreSQLParserMONTH_P, PostgreSQLParserMOVE, PostgreSQLParserNAME_P, PostgreSQLParserNAMES, PostgreSQLParserNEXT, PostgreSQLParserNO, PostgreSQLParserNOTHING, PostgreSQLParserNOTIFY, PostgreSQLParserNOWAIT, PostgreSQLParserNULLS_P, PostgreSQLParserOBJECT_P, PostgreSQLParserOF, PostgreSQLParserOFF, PostgreSQLParserOIDS, PostgreSQLParserOPERATOR, PostgreSQLParserOPTION, PostgreSQLParserOPTIONS, PostgreSQLParserOWNED, PostgreSQLParserOWNER, PostgreSQLParserPARSER, PostgreSQLParserPARTIAL, PostgreSQLParserPARTITION, PostgreSQLParserPASSING, PostgreSQLParserPASSWORD, PostgreSQLParserPLANS, PostgreSQLParserPRECEDING, PostgreSQLParserPREPARE, PostgreSQLParserPREPARED, PostgreSQLParserPRESERVE, PostgreSQLParserPRIOR, PostgreSQLParserPRIVILEGES, PostgreSQLParserPROCEDURAL, PostgreSQLParserPROCEDURE, PostgreSQLParserPROGRAM, PostgreSQLParserQUOTE, PostgreSQLParserRANGE, PostgreSQLParserREAD, PostgreSQLParserREASSIGN, PostgreSQLParserRECHECK, PostgreSQLParserRECURSIVE, PostgreSQLParserREF, PostgreSQLParserREFRESH, PostgreSQLParserREINDEX, PostgreSQLParserRELATIVE_P, PostgreSQLParserRELEASE, PostgreSQLParserRENAME, PostgreSQLParserREPEATABLE, PostgreSQLParserREPLACE, PostgreSQLParserREPLICA, PostgreSQLParserRESET, PostgreSQLParserRESTART, PostgreSQLParserRESTRICT, PostgreSQLParserRETURNS, PostgreSQLParserREVOKE, PostgreSQLParserROLE, PostgreSQLParserROLLBACK, PostgreSQLParserROWS, PostgreSQLParserRULE, PostgreSQLParserSAVEPOINT, PostgreSQLParserSCHEMA, PostgreSQLParserSCROLL, PostgreSQLParserSEARCH, PostgreSQLParserSECOND_P, PostgreSQLParserSECURITY, PostgreSQLParserSEQUENCE, PostgreSQLParserSEQUENCES, PostgreSQLParserSERIALIZABLE, PostgreSQLParserSERVER, PostgreSQLParserSESSION, PostgreSQLParserSET, PostgreSQLParserSHARE, PostgreSQLParserSHOW, PostgreSQLParserSIMPLE, PostgreSQLParserSNAPSHOT, PostgreSQLParserSTABLE, PostgreSQLParserSTANDALONE_P, PostgreSQLParserSTART, PostgreSQLParserSTATEMENT, PostgreSQLParserSTATISTICS, PostgreSQLParserSTDIN, PostgreSQLParserSTDOUT, PostgreSQLParserSTORAGE, PostgreSQLParserSTRICT_P, PostgreSQLParserSTRIP_P, PostgreSQLParserSYSID, PostgreSQLParserSYSTEM_P, PostgreSQLParserTABLES, PostgreSQLParserTABLESPACE, PostgreSQLParserTEMP, PostgreSQLParserTEMPLATE, PostgreSQLParserTEMPORARY, PostgreSQLParserTEXT_P, PostgreSQLParserTRANSACTION, PostgreSQLParserTRIGGER, PostgreSQLParserTRUNCATE, PostgreSQLParserTRUSTED, PostgreSQLParserTYPE_P, PostgreSQLParserTYPES_P, PostgreSQLParserUNBOUNDED, PostgreSQLParserUNCOMMITTED, PostgreSQLParserUNENCRYPTED, PostgreSQLParserUNKNOWN, PostgreSQLParserUNLISTEN, PostgreSQLParserUNLOGGED, PostgreSQLParserUNTIL, PostgreSQLParserUPDATE, PostgreSQLParserVACUUM, PostgreSQLParserVALID, PostgreSQLParserVALIDATE, PostgreSQLParserVALIDATOR, PostgreSQLParserVARYING, PostgreSQLParserVERSION_P, PostgreSQLParserVIEW, PostgreSQLParserVOLATILE, PostgreSQLParserWHITESPACE_P, PostgreSQLParserWITHOUT, PostgreSQLParserWORK, PostgreSQLParserWRAPPER, PostgreSQLParserWRITE, PostgreSQLParserXML_P, PostgreSQLParserYEAR_P, PostgreSQLParserYES_P, PostgreSQLParserZONE, PostgreSQLParserBETWEEN, PostgreSQLParserBIGINT, PostgreSQLParserBIT, PostgreSQLParserBOOLEAN_P, PostgreSQLParserCHAR_P, PostgreSQLParserCHARACTER, PostgreSQLParserCOALESCE, PostgreSQLParserDEC, PostgreSQLParserDECIMAL_P, PostgreSQLParserEXISTS, PostgreSQLParserEXTRACT, PostgreSQLParserFLOAT_P, PostgreSQLParserGREATEST, PostgreSQLParserINOUT, PostgreSQLParserINT_P, PostgreSQLParserINTEGER, PostgreSQLParserINTERVAL, PostgreSQLParserLEAST, PostgreSQLParserNATIONAL, PostgreSQLParserNCHAR, PostgreSQLParserNONE, PostgreSQLParserNULLIF, PostgreSQLParserNUMERIC, PostgreSQLParserOVERLAY, PostgreSQLParserPOSITION, PostgreSQLParserPRECISION, PostgreSQLParserREAL, PostgreSQLParserROW, PostgreSQLParserSETOF, PostgreSQLParserSMALLINT, PostgreSQLParserSUBSTRING, PostgreSQLParserTIME, PostgreSQLParserTIMESTAMP, PostgreSQLParserTREAT, PostgreSQLParserTRIM, PostgreSQLParserVALUES, PostgreSQLParserVARCHAR, PostgreSQLParserXMLATTRIBUTES, PostgreSQLParserXMLCOMMENT, PostgreSQLParserXMLAGG, PostgreSQLParserXML_IS_WELL_FORMED, PostgreSQLParserXML_IS_WELL_FORMED_DOCUMENT, PostgreSQLParserXML_IS_WELL_FORMED_CONTENT, PostgreSQLParserXPATH, PostgreSQLParserXPATH_EXISTS, PostgreSQLParserXMLCONCAT, PostgreSQLParserXMLELEMENT, PostgreSQLParserXMLEXISTS, PostgreSQLParserXMLFOREST, PostgreSQLParserXMLPARSE, PostgreSQLParserXMLPI, PostgreSQLParserXMLROOT, PostgreSQLParserXMLSERIALIZE, PostgreSQLParserCALL, PostgreSQLParserCURRENT_P, PostgreSQLParserATTACH, PostgreSQLParserDETACH, PostgreSQLParserEXPRESSION, PostgreSQLParserGENERATED, PostgreSQLParserLOGGED, PostgreSQLParserSTORED, PostgreSQLParserINCLUDE, PostgreSQLParserROUTINE, PostgreSQLParserTRANSFORM, PostgreSQLParserIMPORT_P, PostgreSQLParserPOLICY, PostgreSQLParserMETHOD, PostgreSQLParserREFERENCING, PostgreSQLParserNEW, PostgreSQLParserOLD, PostgreSQLParserVALUE_P, PostgreSQLParserSUBSCRIPTION, PostgreSQLParserPUBLICATION, PostgreSQLParserOUT_P, PostgreSQLParserROUTINES, PostgreSQLParserSCHEMAS, PostgreSQLParserPROCEDURES, PostgreSQLParserINPUT_P, PostgreSQLParserSUPPORT, PostgreSQLParserPARALLEL, PostgreSQLParserSQL_P, PostgreSQLParserDEPENDS, PostgreSQLParserOVERRIDING, PostgreSQLParserCONFLICT, PostgreSQLParserSKIP_P, PostgreSQLParserLOCKED, PostgreSQLParserTIES, PostgreSQLParserROLLUP, PostgreSQLParserCUBE, PostgreSQLParserGROUPING, PostgreSQLParserSETS, PostgreSQLParserORDINALITY, PostgreSQLParserXMLTABLE, PostgreSQLParserCOLUMNS, PostgreSQLParserXMLNAMESPACES, PostgreSQLParserROWTYPE, PostgreSQLParserNORMALIZED, PostgreSQLParserWITHIN, PostgreSQLParserFILTER, PostgreSQLParserGROUPS, PostgreSQLParserOTHERS, PostgreSQLParserNFC, PostgreSQLParserNFD, PostgreSQLParserNFKC, PostgreSQLParserNFKD, PostgreSQLParserUESCAPE, PostgreSQLParserVIEWS, PostgreSQLParserNORMALIZE, PostgreSQLParserDUMP, PostgreSQLParserPRINT_STRICT_PARAMS, PostgreSQLParserVARIABLE_CONFLICT, PostgreSQLParserERROR, PostgreSQLParserUSE_VARIABLE, PostgreSQLParserUSE_COLUMN, PostgreSQLParserALIAS, PostgreSQLParserCONSTANT, PostgreSQLParserPERFORM, PostgreSQLParserGET, PostgreSQLParserDIAGNOSTICS, PostgreSQLParserSTACKED, PostgreSQLParserELSIF, PostgreSQLParserREVERSE, PostgreSQLParserSLICE, PostgreSQLParserEXIT, PostgreSQLParserRETURN, PostgreSQLParserQUERY, PostgreSQLParserRAISE, PostgreSQLParserSQLSTATE, PostgreSQLParserDEBUG, PostgreSQLParserLOG, PostgreSQLParserINFO, PostgreSQLParserNOTICE, PostgreSQLParserWARNING, PostgreSQLParserEXCEPTION, PostgreSQLParserASSERT, PostgreSQLParserOPEN, PostgreSQLParserABS, PostgreSQLParserCBRT, PostgreSQLParserCEIL, PostgreSQLParserCEILING, PostgreSQLParserDEGREES, PostgreSQLParserDIV, PostgreSQLParserEXP, PostgreSQLParserFACTORIAL, PostgreSQLParserFLOOR, PostgreSQLParserGCD, PostgreSQLParserLCM, PostgreSQLParserLN, PostgreSQLParserLOG10, PostgreSQLParserMIN_SCALE, PostgreSQLParserMOD, PostgreSQLParserPI, PostgreSQLParserPOWER, PostgreSQLParserRADIANS, PostgreSQLParserROUND, PostgreSQLParserSCALE, PostgreSQLParserSIGN, PostgreSQLParserSQRT, PostgreSQLParserTRIM_SCALE, PostgreSQLParserTRUNC, PostgreSQLParserWIDTH_BUCKET, PostgreSQLParserRANDOM, PostgreSQLParserSETSEED, PostgreSQLParserACOS, PostgreSQLParserACOSD, PostgreSQLParserASIN, PostgreSQLParserASIND, PostgreSQLParserATAN, PostgreSQLParserATAND, PostgreSQLParserATAN2, PostgreSQLParserATAN2D, PostgreSQLParserCOS, PostgreSQLParserCOSD, PostgreSQLParserCOT, PostgreSQLParserCOTD, PostgreSQLParserSIN, PostgreSQLParserSIND, PostgreSQLParserTAN, PostgreSQLParserTAND, PostgreSQLParserSINH, PostgreSQLParserCOSH, PostgreSQLParserTANH, PostgreSQLParserASINH, PostgreSQLParserACOSH, PostgreSQLParserATANH, PostgreSQLParserBIT_LENGTH, PostgreSQLParserCHAR_LENGTH, PostgreSQLParserCHARACTER_LENGTH, PostgreSQLParserLOWER, PostgreSQLParserOCTET_LENGTH, PostgreSQLParserUPPER, PostgreSQLParserASCII, PostgreSQLParserBTRIM, PostgreSQLParserCHR, PostgreSQLParserCONCAT, PostgreSQLParserCONCAT_WS, PostgreSQLParserFORMAT, PostgreSQLParserINITCAP, PostgreSQLParserLENGTH, PostgreSQLParserLPAD, PostgreSQLParserLTRIM, PostgreSQLParserMD5, PostgreSQLParserPARSE_IDENT, PostgreSQLParserPG_CLIENT_ENCODING, PostgreSQLParserQUOTE_IDENT, PostgreSQLParserQUOTE_LITERAL, PostgreSQLParserQUOTE_NULLABLE, PostgreSQLParserREGEXP_COUNT, PostgreSQLParserREGEXP_INSTR, PostgreSQLParserREGEXP_LIKE, PostgreSQLParserREGEXP_MATCH, PostgreSQLParserREGEXP_MATCHES, PostgreSQLParserREGEXP_REPLACE, PostgreSQLParserREGEXP_SPLIT_TO_ARRAY, PostgreSQLParserREGEXP_SPLIT_TO_TABLE, PostgreSQLParserREGEXP_SUBSTR, PostgreSQLParserREPEAT, PostgreSQLParserRPAD, PostgreSQLParserRTRIM, PostgreSQLParserSPLIT_PART, PostgreSQLParserSTARTS_WITH, PostgreSQLParserSTRING_TO_ARRAY, PostgreSQLParserSTRING_TO_TABLE, PostgreSQLParserSTRPOS, PostgreSQLParserSUBSTR, PostgreSQLParserTO_ASCII, PostgreSQLParserTO_HEX, PostgreSQLParserTRANSLATE, PostgreSQLParserUNISTR, PostgreSQLParserAGE, PostgreSQLParserCLOCK_TIMESTAMP, PostgreSQLParserDATE_BIN, PostgreSQLParserDATE_PART, PostgreSQLParserDATE_TRUNC, PostgreSQLParserISFINITE, PostgreSQLParserJUSTIFY_DAYS, PostgreSQLParserJUSTIFY_HOURS, PostgreSQLParserJUSTIFY_INTERVAL, PostgreSQLParserMAKE_DATE, PostgreSQLParserMAKE_INTERVAL, PostgreSQLParserMAKE_TIME, PostgreSQLParserMAKE_TIMESTAMP, PostgreSQLParserMAKE_TIMESTAMPTZ, PostgreSQLParserNOW, PostgreSQLParserSTATEMENT_TIMESTAMP, PostgreSQLParserTIMEOFDAY, PostgreSQLParserTRANSACTION_TIMESTAMP, PostgreSQLParserTO_TIMESTAMP, PostgreSQLParserTO_CHAR, PostgreSQLParserTO_DATE, PostgreSQLParserTO_NUMBER, PostgreSQLParserIdentifier, PostgreSQLParserQuotedIdentifier, PostgreSQLParserUnicodeQuotedIdentifier, PostgreSQLParserPLSQLVARIABLENAME, PostgreSQLParserPLSQLIDENTIFIER:
			{
				p.SetState(9384)
				p.Colid()
			}

		default:
			p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
			goto errorExit
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)

	case antlr.ATNInvalidAltNumber:
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IWindow_specificationContext is an interface to support dynamic dispatch.
type IWindow_specificationContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	OPEN_PAREN() antlr.TerminalNode
	Opt_existing_window_name() IOpt_existing_window_nameContext
	Opt_partition_clause() IOpt_partition_clauseContext
	Opt_sort_clause() IOpt_sort_clauseContext
	Opt_frame_clause() IOpt_frame_clauseContext
	CLOSE_PAREN() antlr.TerminalNode

	// IsWindow_specificationContext differentiates from other interfaces.
	IsWindow_specificationContext()
}

type Window_specificationContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyWindow_specificationContext() *Window_specificationContext {
	var p = new(Window_specificationContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_window_specification
	return p
}

func InitEmptyWindow_specificationContext(p *Window_specificationContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_window_specification
}

func (*Window_specificationContext) IsWindow_specificationContext() {}

func NewWindow_specificationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Window_specificationContext {
	var p = new(Window_specificationContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_window_specification

	return p
}

func (s *Window_specificationContext) GetParser() antlr.Parser { return s.parser }

func (s *Window_specificationContext) OPEN_PAREN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserOPEN_PAREN, 0)
}

func (s *Window_specificationContext) Opt_existing_window_name() IOpt_existing_window_nameContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOpt_existing_window_nameContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOpt_existing_window_nameContext)
}

func (s *Window_specificationContext) Opt_partition_clause() IOpt_partition_clauseContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOpt_partition_clauseContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOpt_partition_clauseContext)
}

func (s *Window_specificationContext) Opt_sort_clause() IOpt_sort_clauseContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOpt_sort_clauseContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOpt_sort_clauseContext)
}

func (s *Window_specificationContext) Opt_frame_clause() IOpt_frame_clauseContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOpt_frame_clauseContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOpt_frame_clauseContext)
}

func (s *Window_specificationContext) CLOSE_PAREN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCLOSE_PAREN, 0)
}

func (s *Window_specificationContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Window_specificationContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Window_specificationContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterWindow_specification(s)
	}
}

func (s *Window_specificationContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitWindow_specification(s)
	}
}

func (s *Window_specificationContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitWindow_specification(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Window_specification() (localctx IWindow_specificationContext) {
	localctx = NewWindow_specificationContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1248, PostgreSQLParserRULE_window_specification)
	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(9390)
		p.Match(PostgreSQLParserOPEN_PAREN)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(9391)
		p.Opt_existing_window_name()
	}
	{
		p.SetState(9392)
		p.Opt_partition_clause()
	}
	{
		p.SetState(9393)
		p.Opt_sort_clause()
	}
	{
		p.SetState(9394)
		p.Opt_frame_clause()
	}
	{
		p.SetState(9395)
		p.Match(PostgreSQLParserCLOSE_PAREN)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IOpt_existing_window_nameContext is an interface to support dynamic dispatch.
type IOpt_existing_window_nameContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Colid() IColidContext

	// IsOpt_existing_window_nameContext differentiates from other interfaces.
	IsOpt_existing_window_nameContext()
}

type Opt_existing_window_nameContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyOpt_existing_window_nameContext() *Opt_existing_window_nameContext {
	var p = new(Opt_existing_window_nameContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opt_existing_window_name
	return p
}

func InitEmptyOpt_existing_window_nameContext(p *Opt_existing_window_nameContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opt_existing_window_name
}

func (*Opt_existing_window_nameContext) IsOpt_existing_window_nameContext() {}

func NewOpt_existing_window_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_existing_window_nameContext {
	var p = new(Opt_existing_window_nameContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_opt_existing_window_name

	return p
}

func (s *Opt_existing_window_nameContext) GetParser() antlr.Parser { return s.parser }

func (s *Opt_existing_window_nameContext) Colid() IColidContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IColidContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IColidContext)
}

func (s *Opt_existing_window_nameContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Opt_existing_window_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Opt_existing_window_nameContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterOpt_existing_window_name(s)
	}
}

func (s *Opt_existing_window_nameContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitOpt_existing_window_name(s)
	}
}

func (s *Opt_existing_window_nameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitOpt_existing_window_name(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Opt_existing_window_name() (localctx IOpt_existing_window_nameContext) {
	localctx = NewOpt_existing_window_nameContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1250, PostgreSQLParserRULE_opt_existing_window_name)
	p.SetState(9399)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 604, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(9397)
			p.Colid()
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)

	case antlr.ATNInvalidAltNumber:
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IOpt_partition_clauseContext is an interface to support dynamic dispatch.
type IOpt_partition_clauseContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	PARTITION() antlr.TerminalNode
	BY() antlr.TerminalNode
	Expr_list() IExpr_listContext

	// IsOpt_partition_clauseContext differentiates from other interfaces.
	IsOpt_partition_clauseContext()
}

type Opt_partition_clauseContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyOpt_partition_clauseContext() *Opt_partition_clauseContext {
	var p = new(Opt_partition_clauseContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opt_partition_clause
	return p
}

func InitEmptyOpt_partition_clauseContext(p *Opt_partition_clauseContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opt_partition_clause
}

func (*Opt_partition_clauseContext) IsOpt_partition_clauseContext() {}

func NewOpt_partition_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_partition_clauseContext {
	var p = new(Opt_partition_clauseContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_opt_partition_clause

	return p
}

func (s *Opt_partition_clauseContext) GetParser() antlr.Parser { return s.parser }

func (s *Opt_partition_clauseContext) PARTITION() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserPARTITION, 0)
}

func (s *Opt_partition_clauseContext) BY() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserBY, 0)
}

func (s *Opt_partition_clauseContext) Expr_list() IExpr_listContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IExpr_listContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IExpr_listContext)
}

func (s *Opt_partition_clauseContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Opt_partition_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Opt_partition_clauseContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterOpt_partition_clause(s)
	}
}

func (s *Opt_partition_clauseContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitOpt_partition_clause(s)
	}
}

func (s *Opt_partition_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitOpt_partition_clause(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Opt_partition_clause() (localctx IOpt_partition_clauseContext) {
	localctx = NewOpt_partition_clauseContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1252, PostgreSQLParserRULE_opt_partition_clause)
	p.SetState(9405)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetTokenStream().LA(1) {
	case PostgreSQLParserPARTITION:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(9401)
			p.Match(PostgreSQLParserPARTITION)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(9402)
			p.Match(PostgreSQLParserBY)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(9403)
			p.Expr_list()
		}

	case PostgreSQLParserCLOSE_PAREN, PostgreSQLParserORDER, PostgreSQLParserRANGE, PostgreSQLParserROWS, PostgreSQLParserGROUPS:
		p.EnterOuterAlt(localctx, 2)

	default:
		p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IOpt_frame_clauseContext is an interface to support dynamic dispatch.
type IOpt_frame_clauseContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	RANGE() antlr.TerminalNode
	Frame_extent() IFrame_extentContext
	Opt_window_exclusion_clause() IOpt_window_exclusion_clauseContext
	ROWS() antlr.TerminalNode
	GROUPS() antlr.TerminalNode

	// IsOpt_frame_clauseContext differentiates from other interfaces.
	IsOpt_frame_clauseContext()
}

type Opt_frame_clauseContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyOpt_frame_clauseContext() *Opt_frame_clauseContext {
	var p = new(Opt_frame_clauseContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opt_frame_clause
	return p
}

func InitEmptyOpt_frame_clauseContext(p *Opt_frame_clauseContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opt_frame_clause
}

func (*Opt_frame_clauseContext) IsOpt_frame_clauseContext() {}

func NewOpt_frame_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_frame_clauseContext {
	var p = new(Opt_frame_clauseContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_opt_frame_clause

	return p
}

func (s *Opt_frame_clauseContext) GetParser() antlr.Parser { return s.parser }

func (s *Opt_frame_clauseContext) RANGE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserRANGE, 0)
}

func (s *Opt_frame_clauseContext) Frame_extent() IFrame_extentContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IFrame_extentContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IFrame_extentContext)
}

func (s *Opt_frame_clauseContext) Opt_window_exclusion_clause() IOpt_window_exclusion_clauseContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOpt_window_exclusion_clauseContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOpt_window_exclusion_clauseContext)
}

func (s *Opt_frame_clauseContext) ROWS() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserROWS, 0)
}

func (s *Opt_frame_clauseContext) GROUPS() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserGROUPS, 0)
}

func (s *Opt_frame_clauseContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Opt_frame_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Opt_frame_clauseContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterOpt_frame_clause(s)
	}
}

func (s *Opt_frame_clauseContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitOpt_frame_clause(s)
	}
}

func (s *Opt_frame_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitOpt_frame_clause(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Opt_frame_clause() (localctx IOpt_frame_clauseContext) {
	localctx = NewOpt_frame_clauseContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1254, PostgreSQLParserRULE_opt_frame_clause)
	p.SetState(9420)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetTokenStream().LA(1) {
	case PostgreSQLParserRANGE:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(9407)
			p.Match(PostgreSQLParserRANGE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(9408)
			p.Frame_extent()
		}
		{
			p.SetState(9409)
			p.Opt_window_exclusion_clause()
		}

	case PostgreSQLParserROWS:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(9411)
			p.Match(PostgreSQLParserROWS)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(9412)
			p.Frame_extent()
		}
		{
			p.SetState(9413)
			p.Opt_window_exclusion_clause()
		}

	case PostgreSQLParserGROUPS:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(9415)
			p.Match(PostgreSQLParserGROUPS)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(9416)
			p.Frame_extent()
		}
		{
			p.SetState(9417)
			p.Opt_window_exclusion_clause()
		}

	case PostgreSQLParserCLOSE_PAREN:
		p.EnterOuterAlt(localctx, 4)

	default:
		p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IFrame_extentContext is an interface to support dynamic dispatch.
type IFrame_extentContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	AllFrame_bound() []IFrame_boundContext
	Frame_bound(i int) IFrame_boundContext
	BETWEEN() antlr.TerminalNode
	AND() antlr.TerminalNode

	// IsFrame_extentContext differentiates from other interfaces.
	IsFrame_extentContext()
}

type Frame_extentContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyFrame_extentContext() *Frame_extentContext {
	var p = new(Frame_extentContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_frame_extent
	return p
}

func InitEmptyFrame_extentContext(p *Frame_extentContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_frame_extent
}

func (*Frame_extentContext) IsFrame_extentContext() {}

func NewFrame_extentContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Frame_extentContext {
	var p = new(Frame_extentContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_frame_extent

	return p
}

func (s *Frame_extentContext) GetParser() antlr.Parser { return s.parser }

func (s *Frame_extentContext) AllFrame_bound() []IFrame_boundContext {
	children := s.GetChildren()
	len := 0
	for _, ctx := range children {
		if _, ok := ctx.(IFrame_boundContext); ok {
			len++
		}
	}

	tst := make([]IFrame_boundContext, len)
	i := 0
	for _, ctx := range children {
		if t, ok := ctx.(IFrame_boundContext); ok {
			tst[i] = t.(IFrame_boundContext)
			i++
		}
	}

	return tst
}

func (s *Frame_extentContext) Frame_bound(i int) IFrame_boundContext {
	var t antlr.RuleContext
	j := 0
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IFrame_boundContext); ok {
			if j == i {
				t = ctx.(antlr.RuleContext)
				break
			}
			j++
		}
	}

	if t == nil {
		return nil
	}

	return t.(IFrame_boundContext)
}

func (s *Frame_extentContext) BETWEEN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserBETWEEN, 0)
}

func (s *Frame_extentContext) AND() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserAND, 0)
}

func (s *Frame_extentContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Frame_extentContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Frame_extentContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterFrame_extent(s)
	}
}

func (s *Frame_extentContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitFrame_extent(s)
	}
}

func (s *Frame_extentContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitFrame_extent(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Frame_extent() (localctx IFrame_extentContext) {
	localctx = NewFrame_extentContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1256, PostgreSQLParserRULE_frame_extent)
	p.SetState(9428)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 607, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(9422)
			p.Frame_bound()
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(9423)
			p.Match(PostgreSQLParserBETWEEN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(9424)
			p.Frame_bound()
		}
		{
			p.SetState(9425)
			p.Match(PostgreSQLParserAND)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(9426)
			p.Frame_bound()
		}

	case antlr.ATNInvalidAltNumber:
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IFrame_boundContext is an interface to support dynamic dispatch.
type IFrame_boundContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	UNBOUNDED() antlr.TerminalNode
	PRECEDING() antlr.TerminalNode
	FOLLOWING() antlr.TerminalNode
	CURRENT_P() antlr.TerminalNode
	ROW() antlr.TerminalNode
	A_expr() IA_exprContext

	// IsFrame_boundContext differentiates from other interfaces.
	IsFrame_boundContext()
}

type Frame_boundContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyFrame_boundContext() *Frame_boundContext {
	var p = new(Frame_boundContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_frame_bound
	return p
}

func InitEmptyFrame_boundContext(p *Frame_boundContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_frame_bound
}

func (*Frame_boundContext) IsFrame_boundContext() {}

func NewFrame_boundContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Frame_boundContext {
	var p = new(Frame_boundContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_frame_bound

	return p
}

func (s *Frame_boundContext) GetParser() antlr.Parser { return s.parser }

func (s *Frame_boundContext) UNBOUNDED() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserUNBOUNDED, 0)
}

func (s *Frame_boundContext) PRECEDING() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserPRECEDING, 0)
}

func (s *Frame_boundContext) FOLLOWING() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserFOLLOWING, 0)
}

func (s *Frame_boundContext) CURRENT_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCURRENT_P, 0)
}

func (s *Frame_boundContext) ROW() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserROW, 0)
}

func (s *Frame_boundContext) A_expr() IA_exprContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IA_exprContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IA_exprContext)
}

func (s *Frame_boundContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Frame_boundContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Frame_boundContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterFrame_bound(s)
	}
}

func (s *Frame_boundContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitFrame_bound(s)
	}
}

func (s *Frame_boundContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitFrame_bound(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Frame_bound() (localctx IFrame_boundContext) {
	localctx = NewFrame_boundContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1258, PostgreSQLParserRULE_frame_bound)
	var _la int

	p.SetState(9437)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 608, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(9430)
			p.Match(PostgreSQLParserUNBOUNDED)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(9431)
			_la = p.GetTokenStream().LA(1)

			if !(_la == PostgreSQLParserFOLLOWING || _la == PostgreSQLParserPRECEDING) {
				p.GetErrorHandler().RecoverInline(p)
			} else {
				p.GetErrorHandler().ReportMatch(p)
				p.Consume()
			}
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(9432)
			p.Match(PostgreSQLParserCURRENT_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(9433)
			p.Match(PostgreSQLParserROW)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 3:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(9434)
			p.A_expr()
		}
		{
			p.SetState(9435)
			_la = p.GetTokenStream().LA(1)

			if !(_la == PostgreSQLParserFOLLOWING || _la == PostgreSQLParserPRECEDING) {
				p.GetErrorHandler().RecoverInline(p)
			} else {
				p.GetErrorHandler().ReportMatch(p)
				p.Consume()
			}
		}

	case antlr.ATNInvalidAltNumber:
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IOpt_window_exclusion_clauseContext is an interface to support dynamic dispatch.
type IOpt_window_exclusion_clauseContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	EXCLUDE() antlr.TerminalNode
	CURRENT_P() antlr.TerminalNode
	ROW() antlr.TerminalNode
	GROUP_P() antlr.TerminalNode
	TIES() antlr.TerminalNode
	NO() antlr.TerminalNode
	OTHERS() antlr.TerminalNode

	// IsOpt_window_exclusion_clauseContext differentiates from other interfaces.
	IsOpt_window_exclusion_clauseContext()
}

type Opt_window_exclusion_clauseContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyOpt_window_exclusion_clauseContext() *Opt_window_exclusion_clauseContext {
	var p = new(Opt_window_exclusion_clauseContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opt_window_exclusion_clause
	return p
}

func InitEmptyOpt_window_exclusion_clauseContext(p *Opt_window_exclusion_clauseContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opt_window_exclusion_clause
}

func (*Opt_window_exclusion_clauseContext) IsOpt_window_exclusion_clauseContext() {}

func NewOpt_window_exclusion_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_window_exclusion_clauseContext {
	var p = new(Opt_window_exclusion_clauseContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_opt_window_exclusion_clause

	return p
}

func (s *Opt_window_exclusion_clauseContext) GetParser() antlr.Parser { return s.parser }

func (s *Opt_window_exclusion_clauseContext) EXCLUDE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserEXCLUDE, 0)
}

func (s *Opt_window_exclusion_clauseContext) CURRENT_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCURRENT_P, 0)
}

func (s *Opt_window_exclusion_clauseContext) ROW() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserROW, 0)
}

func (s *Opt_window_exclusion_clauseContext) GROUP_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserGROUP_P, 0)
}

func (s *Opt_window_exclusion_clauseContext) TIES() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserTIES, 0)
}

func (s *Opt_window_exclusion_clauseContext) NO() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserNO, 0)
}

func (s *Opt_window_exclusion_clauseContext) OTHERS() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserOTHERS, 0)
}

func (s *Opt_window_exclusion_clauseContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Opt_window_exclusion_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Opt_window_exclusion_clauseContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterOpt_window_exclusion_clause(s)
	}
}

func (s *Opt_window_exclusion_clauseContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitOpt_window_exclusion_clause(s)
	}
}

func (s *Opt_window_exclusion_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitOpt_window_exclusion_clause(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Opt_window_exclusion_clause() (localctx IOpt_window_exclusion_clauseContext) {
	localctx = NewOpt_window_exclusion_clauseContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1260, PostgreSQLParserRULE_opt_window_exclusion_clause)
	p.SetState(9449)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetTokenStream().LA(1) {
	case PostgreSQLParserEXCLUDE:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(9439)
			p.Match(PostgreSQLParserEXCLUDE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		p.SetState(9446)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}

		switch p.GetTokenStream().LA(1) {
		case PostgreSQLParserCURRENT_P:
			{
				p.SetState(9440)
				p.Match(PostgreSQLParserCURRENT_P)
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}
			{
				p.SetState(9441)
				p.Match(PostgreSQLParserROW)
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}

		case PostgreSQLParserGROUP_P:
			{
				p.SetState(9442)
				p.Match(PostgreSQLParserGROUP_P)
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}

		case PostgreSQLParserTIES:
			{
				p.SetState(9443)
				p.Match(PostgreSQLParserTIES)
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}

		case PostgreSQLParserNO:
			{
				p.SetState(9444)
				p.Match(PostgreSQLParserNO)
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}
			{
				p.SetState(9445)
				p.Match(PostgreSQLParserOTHERS)
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}

		default:
			p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
			goto errorExit
		}

	case PostgreSQLParserCLOSE_PAREN:
		p.EnterOuterAlt(localctx, 2)

	default:
		p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IRowContext is an interface to support dynamic dispatch.
type IRowContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	ROW() antlr.TerminalNode
	OPEN_PAREN() antlr.TerminalNode
	CLOSE_PAREN() antlr.TerminalNode
	Expr_list() IExpr_listContext
	COMMA() antlr.TerminalNode
	A_expr() IA_exprContext

	// IsRowContext differentiates from other interfaces.
	IsRowContext()
}

type RowContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyRowContext() *RowContext {
	var p = new(RowContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_row
	return p
}

func InitEmptyRowContext(p *RowContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_row
}

func (*RowContext) IsRowContext() {}

func NewRowContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *RowContext {
	var p = new(RowContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_row

	return p
}

func (s *RowContext) GetParser() antlr.Parser { return s.parser }

func (s *RowContext) ROW() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserROW, 0)
}

func (s *RowContext) OPEN_PAREN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserOPEN_PAREN, 0)
}

func (s *RowContext) CLOSE_PAREN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCLOSE_PAREN, 0)
}

func (s *RowContext) Expr_list() IExpr_listContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IExpr_listContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IExpr_listContext)
}

func (s *RowContext) COMMA() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCOMMA, 0)
}

func (s *RowContext) A_expr() IA_exprContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IA_exprContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IA_exprContext)
}

func (s *RowContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *RowContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *RowContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterRow(s)
	}
}

func (s *RowContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitRow(s)
	}
}

func (s *RowContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitRow(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Row() (localctx IRowContext) {
	localctx = NewRowContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1262, PostgreSQLParserRULE_row)
	var _la int

	p.SetState(9463)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetTokenStream().LA(1) {
	case PostgreSQLParserROW:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(9451)
			p.Match(PostgreSQLParserROW)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(9452)
			p.Match(PostgreSQLParserOPEN_PAREN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		p.SetState(9454)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}
		_la = p.GetTokenStream().LA(1)

		if ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&3620818277858553860) != 0) || ((int64((_la-75)) & ^0x3f) == 0 && ((int64(1)<<(_la-75))&-2120073201) != 0) || ((int64((_la-139)) & ^0x3f) == 0 && ((int64(1)<<(_la-139))&-1) != 0) || ((int64((_la-203)) & ^0x3f) == 0 && ((int64(1)<<(_la-203))&-1266637395197953) != 0) || ((int64((_la-267)) & ^0x3f) == 0 && ((int64(1)<<(_la-267))&-1) != 0) || ((int64((_la-331)) & ^0x3f) == 0 && ((int64(1)<<(_la-331))&-1) != 0) || ((int64((_la-395)) & ^0x3f) == 0 && ((int64(1)<<(_la-395))&-576460752303423489) != 0) || ((int64((_la-459)) & ^0x3f) == 0 && ((int64(1)<<(_la-459))&-1153009465537069057) != 0) || ((int64((_la-523)) & ^0x3f) == 0 && ((int64(1)<<(_la-523))&-1) != 0) || ((int64((_la-587)) & ^0x3f) == 0 && ((int64(1)<<(_la-587))&-3150267939345661953) != 0) || ((int64((_la-654)) & ^0x3f) == 0 && ((int64(1)<<(_la-654))&131537) != 0) {
			{
				p.SetState(9453)
				p.Expr_list()
			}

		}
		{
			p.SetState(9456)
			p.Match(PostgreSQLParserCLOSE_PAREN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case PostgreSQLParserOPEN_PAREN:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(9457)
			p.Match(PostgreSQLParserOPEN_PAREN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(9458)
			p.Expr_list()
		}
		{
			p.SetState(9459)
			p.Match(PostgreSQLParserCOMMA)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(9460)
			p.A_expr()
		}
		{
			p.SetState(9461)
			p.Match(PostgreSQLParserCLOSE_PAREN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	default:
		p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IExplicit_rowContext is an interface to support dynamic dispatch.
type IExplicit_rowContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	ROW() antlr.TerminalNode
	OPEN_PAREN() antlr.TerminalNode
	CLOSE_PAREN() antlr.TerminalNode
	Expr_list() IExpr_listContext

	// IsExplicit_rowContext differentiates from other interfaces.
	IsExplicit_rowContext()
}

type Explicit_rowContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyExplicit_rowContext() *Explicit_rowContext {
	var p = new(Explicit_rowContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_explicit_row
	return p
}

func InitEmptyExplicit_rowContext(p *Explicit_rowContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_explicit_row
}

func (*Explicit_rowContext) IsExplicit_rowContext() {}

func NewExplicit_rowContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Explicit_rowContext {
	var p = new(Explicit_rowContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_explicit_row

	return p
}

func (s *Explicit_rowContext) GetParser() antlr.Parser { return s.parser }

func (s *Explicit_rowContext) ROW() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserROW, 0)
}

func (s *Explicit_rowContext) OPEN_PAREN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserOPEN_PAREN, 0)
}

func (s *Explicit_rowContext) CLOSE_PAREN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCLOSE_PAREN, 0)
}

func (s *Explicit_rowContext) Expr_list() IExpr_listContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IExpr_listContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IExpr_listContext)
}

func (s *Explicit_rowContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Explicit_rowContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Explicit_rowContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterExplicit_row(s)
	}
}

func (s *Explicit_rowContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitExplicit_row(s)
	}
}

func (s *Explicit_rowContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitExplicit_row(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Explicit_row() (localctx IExplicit_rowContext) {
	localctx = NewExplicit_rowContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1264, PostgreSQLParserRULE_explicit_row)
	var _la int

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(9465)
		p.Match(PostgreSQLParserROW)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(9466)
		p.Match(PostgreSQLParserOPEN_PAREN)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	p.SetState(9468)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}
	_la = p.GetTokenStream().LA(1)

	if ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&3620818277858553860) != 0) || ((int64((_la-75)) & ^0x3f) == 0 && ((int64(1)<<(_la-75))&-2120073201) != 0) || ((int64((_la-139)) & ^0x3f) == 0 && ((int64(1)<<(_la-139))&-1) != 0) || ((int64((_la-203)) & ^0x3f) == 0 && ((int64(1)<<(_la-203))&-1266637395197953) != 0) || ((int64((_la-267)) & ^0x3f) == 0 && ((int64(1)<<(_la-267))&-1) != 0) || ((int64((_la-331)) & ^0x3f) == 0 && ((int64(1)<<(_la-331))&-1) != 0) || ((int64((_la-395)) & ^0x3f) == 0 && ((int64(1)<<(_la-395))&-576460752303423489) != 0) || ((int64((_la-459)) & ^0x3f) == 0 && ((int64(1)<<(_la-459))&-1153009465537069057) != 0) || ((int64((_la-523)) & ^0x3f) == 0 && ((int64(1)<<(_la-523))&-1) != 0) || ((int64((_la-587)) & ^0x3f) == 0 && ((int64(1)<<(_la-587))&-3150267939345661953) != 0) || ((int64((_la-654)) & ^0x3f) == 0 && ((int64(1)<<(_la-654))&131537) != 0) {
		{
			p.SetState(9467)
			p.Expr_list()
		}

	}
	{
		p.SetState(9470)
		p.Match(PostgreSQLParserCLOSE_PAREN)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IImplicit_rowContext is an interface to support dynamic dispatch.
type IImplicit_rowContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	OPEN_PAREN() antlr.TerminalNode
	Expr_list() IExpr_listContext
	COMMA() antlr.TerminalNode
	A_expr() IA_exprContext
	CLOSE_PAREN() antlr.TerminalNode

	// IsImplicit_rowContext differentiates from other interfaces.
	IsImplicit_rowContext()
}

type Implicit_rowContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyImplicit_rowContext() *Implicit_rowContext {
	var p = new(Implicit_rowContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_implicit_row
	return p
}

func InitEmptyImplicit_rowContext(p *Implicit_rowContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_implicit_row
}

func (*Implicit_rowContext) IsImplicit_rowContext() {}

func NewImplicit_rowContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Implicit_rowContext {
	var p = new(Implicit_rowContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_implicit_row

	return p
}

func (s *Implicit_rowContext) GetParser() antlr.Parser { return s.parser }

func (s *Implicit_rowContext) OPEN_PAREN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserOPEN_PAREN, 0)
}

func (s *Implicit_rowContext) Expr_list() IExpr_listContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IExpr_listContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IExpr_listContext)
}

func (s *Implicit_rowContext) COMMA() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCOMMA, 0)
}

func (s *Implicit_rowContext) A_expr() IA_exprContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IA_exprContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IA_exprContext)
}

func (s *Implicit_rowContext) CLOSE_PAREN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCLOSE_PAREN, 0)
}

func (s *Implicit_rowContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Implicit_rowContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Implicit_rowContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterImplicit_row(s)
	}
}

func (s *Implicit_rowContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitImplicit_row(s)
	}
}

func (s *Implicit_rowContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitImplicit_row(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Implicit_row() (localctx IImplicit_rowContext) {
	localctx = NewImplicit_rowContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1266, PostgreSQLParserRULE_implicit_row)
	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(9472)
		p.Match(PostgreSQLParserOPEN_PAREN)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(9473)
		p.Expr_list()
	}
	{
		p.SetState(9474)
		p.Match(PostgreSQLParserCOMMA)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(9475)
		p.A_expr()
	}
	{
		p.SetState(9476)
		p.Match(PostgreSQLParserCLOSE_PAREN)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// ISub_typeContext is an interface to support dynamic dispatch.
type ISub_typeContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	ANY() antlr.TerminalNode
	SOME() antlr.TerminalNode
	ALL() antlr.TerminalNode

	// IsSub_typeContext differentiates from other interfaces.
	IsSub_typeContext()
}

type Sub_typeContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptySub_typeContext() *Sub_typeContext {
	var p = new(Sub_typeContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_sub_type
	return p
}

func InitEmptySub_typeContext(p *Sub_typeContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_sub_type
}

func (*Sub_typeContext) IsSub_typeContext() {}

func NewSub_typeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Sub_typeContext {
	var p = new(Sub_typeContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_sub_type

	return p
}

func (s *Sub_typeContext) GetParser() antlr.Parser { return s.parser }

func (s *Sub_typeContext) ANY() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserANY, 0)
}

func (s *Sub_typeContext) SOME() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserSOME, 0)
}

func (s *Sub_typeContext) ALL() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserALL, 0)
}

func (s *Sub_typeContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Sub_typeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Sub_typeContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterSub_type(s)
	}
}

func (s *Sub_typeContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitSub_type(s)
	}
}

func (s *Sub_typeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitSub_type(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Sub_type() (localctx ISub_typeContext) {
	localctx = NewSub_typeContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1268, PostgreSQLParserRULE_sub_type)
	var _la int

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(9478)
		_la = p.GetTokenStream().LA(1)

		if !((int64((_la-30)) & ^0x3f) == 0 && ((int64(1)<<(_la-30))&1152921504606846993) != 0) {
			p.GetErrorHandler().RecoverInline(p)
		} else {
			p.GetErrorHandler().ReportMatch(p)
			p.Consume()
		}
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IAll_opContext is an interface to support dynamic dispatch.
type IAll_opContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Operator() antlr.TerminalNode
	Mathop() IMathopContext

	// IsAll_opContext differentiates from other interfaces.
	IsAll_opContext()
}

type All_opContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyAll_opContext() *All_opContext {
	var p = new(All_opContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_all_op
	return p
}

func InitEmptyAll_opContext(p *All_opContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_all_op
}

func (*All_opContext) IsAll_opContext() {}

func NewAll_opContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *All_opContext {
	var p = new(All_opContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_all_op

	return p
}

func (s *All_opContext) GetParser() antlr.Parser { return s.parser }

func (s *All_opContext) Operator() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserOperator, 0)
}

func (s *All_opContext) Mathop() IMathopContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IMathopContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IMathopContext)
}

func (s *All_opContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *All_opContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *All_opContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterAll_op(s)
	}
}

func (s *All_opContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitAll_op(s)
	}
}

func (s *All_opContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitAll_op(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) All_op() (localctx IAll_opContext) {
	localctx = NewAll_opContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1270, PostgreSQLParserRULE_all_op)
	p.SetState(9482)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetTokenStream().LA(1) {
	case PostgreSQLParserOperator:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(9480)
			p.Match(PostgreSQLParserOperator)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case PostgreSQLParserSTAR, PostgreSQLParserEQUAL, PostgreSQLParserPLUS, PostgreSQLParserMINUS, PostgreSQLParserSLASH, PostgreSQLParserCARET, PostgreSQLParserLT, PostgreSQLParserGT, PostgreSQLParserLESS_EQUALS, PostgreSQLParserGREATER_EQUALS, PostgreSQLParserNOT_EQUALS, PostgreSQLParserPERCENT:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(9481)
			p.Mathop()
		}

	default:
		p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IMathopContext is an interface to support dynamic dispatch.
type IMathopContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	PLUS() antlr.TerminalNode
	MINUS() antlr.TerminalNode
	STAR() antlr.TerminalNode
	SLASH() antlr.TerminalNode
	PERCENT() antlr.TerminalNode
	CARET() antlr.TerminalNode
	LT() antlr.TerminalNode
	GT() antlr.TerminalNode
	EQUAL() antlr.TerminalNode
	LESS_EQUALS() antlr.TerminalNode
	GREATER_EQUALS() antlr.TerminalNode
	NOT_EQUALS() antlr.TerminalNode

	// IsMathopContext differentiates from other interfaces.
	IsMathopContext()
}

type MathopContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyMathopContext() *MathopContext {
	var p = new(MathopContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_mathop
	return p
}

func InitEmptyMathopContext(p *MathopContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_mathop
}

func (*MathopContext) IsMathopContext() {}

func NewMathopContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *MathopContext {
	var p = new(MathopContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_mathop

	return p
}

func (s *MathopContext) GetParser() antlr.Parser { return s.parser }

func (s *MathopContext) PLUS() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserPLUS, 0)
}

func (s *MathopContext) MINUS() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserMINUS, 0)
}

func (s *MathopContext) STAR() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserSTAR, 0)
}

func (s *MathopContext) SLASH() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserSLASH, 0)
}

func (s *MathopContext) PERCENT() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserPERCENT, 0)
}

func (s *MathopContext) CARET() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCARET, 0)
}

func (s *MathopContext) LT() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserLT, 0)
}

func (s *MathopContext) GT() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserGT, 0)
}

func (s *MathopContext) EQUAL() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserEQUAL, 0)
}

func (s *MathopContext) LESS_EQUALS() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserLESS_EQUALS, 0)
}

func (s *MathopContext) GREATER_EQUALS() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserGREATER_EQUALS, 0)
}

func (s *MathopContext) NOT_EQUALS() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserNOT_EQUALS, 0)
}

func (s *MathopContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *MathopContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *MathopContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterMathop(s)
	}
}

func (s *MathopContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitMathop(s)
	}
}

func (s *MathopContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitMathop(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Mathop() (localctx IMathopContext) {
	localctx = NewMathopContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1272, PostgreSQLParserRULE_mathop)
	var _la int

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(9484)
		_la = p.GetTokenStream().LA(1)

		if !((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&178517504) != 0) {
			p.GetErrorHandler().RecoverInline(p)
		} else {
			p.GetErrorHandler().ReportMatch(p)
			p.Consume()
		}
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IQual_opContext is an interface to support dynamic dispatch.
type IQual_opContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Operator() antlr.TerminalNode
	OPERATOR() antlr.TerminalNode
	OPEN_PAREN() antlr.TerminalNode
	Any_operator() IAny_operatorContext
	CLOSE_PAREN() antlr.TerminalNode

	// IsQual_opContext differentiates from other interfaces.
	IsQual_opContext()
}

type Qual_opContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyQual_opContext() *Qual_opContext {
	var p = new(Qual_opContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_qual_op
	return p
}

func InitEmptyQual_opContext(p *Qual_opContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_qual_op
}

func (*Qual_opContext) IsQual_opContext() {}

func NewQual_opContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Qual_opContext {
	var p = new(Qual_opContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_qual_op

	return p
}

func (s *Qual_opContext) GetParser() antlr.Parser { return s.parser }

func (s *Qual_opContext) Operator() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserOperator, 0)
}

func (s *Qual_opContext) OPERATOR() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserOPERATOR, 0)
}

func (s *Qual_opContext) OPEN_PAREN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserOPEN_PAREN, 0)
}

func (s *Qual_opContext) Any_operator() IAny_operatorContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IAny_operatorContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IAny_operatorContext)
}

func (s *Qual_opContext) CLOSE_PAREN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCLOSE_PAREN, 0)
}

func (s *Qual_opContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Qual_opContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Qual_opContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterQual_op(s)
	}
}

func (s *Qual_opContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitQual_op(s)
	}
}

func (s *Qual_opContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitQual_op(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Qual_op() (localctx IQual_opContext) {
	localctx = NewQual_opContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1274, PostgreSQLParserRULE_qual_op)
	p.SetState(9492)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetTokenStream().LA(1) {
	case PostgreSQLParserOperator:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(9486)
			p.Match(PostgreSQLParserOperator)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case PostgreSQLParserOPERATOR:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(9487)
			p.Match(PostgreSQLParserOPERATOR)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(9488)
			p.Match(PostgreSQLParserOPEN_PAREN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(9489)
			p.Any_operator()
		}
		{
			p.SetState(9490)
			p.Match(PostgreSQLParserCLOSE_PAREN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	default:
		p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IQual_all_opContext is an interface to support dynamic dispatch.
type IQual_all_opContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	All_op() IAll_opContext
	OPERATOR() antlr.TerminalNode
	OPEN_PAREN() antlr.TerminalNode
	Any_operator() IAny_operatorContext
	CLOSE_PAREN() antlr.TerminalNode

	// IsQual_all_opContext differentiates from other interfaces.
	IsQual_all_opContext()
}

type Qual_all_opContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyQual_all_opContext() *Qual_all_opContext {
	var p = new(Qual_all_opContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_qual_all_op
	return p
}

func InitEmptyQual_all_opContext(p *Qual_all_opContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_qual_all_op
}

func (*Qual_all_opContext) IsQual_all_opContext() {}

func NewQual_all_opContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Qual_all_opContext {
	var p = new(Qual_all_opContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_qual_all_op

	return p
}

func (s *Qual_all_opContext) GetParser() antlr.Parser { return s.parser }

func (s *Qual_all_opContext) All_op() IAll_opContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IAll_opContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IAll_opContext)
}

func (s *Qual_all_opContext) OPERATOR() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserOPERATOR, 0)
}

func (s *Qual_all_opContext) OPEN_PAREN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserOPEN_PAREN, 0)
}

func (s *Qual_all_opContext) Any_operator() IAny_operatorContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IAny_operatorContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IAny_operatorContext)
}

func (s *Qual_all_opContext) CLOSE_PAREN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCLOSE_PAREN, 0)
}

func (s *Qual_all_opContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Qual_all_opContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Qual_all_opContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterQual_all_op(s)
	}
}

func (s *Qual_all_opContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitQual_all_op(s)
	}
}

func (s *Qual_all_opContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitQual_all_op(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Qual_all_op() (localctx IQual_all_opContext) {
	localctx = NewQual_all_opContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1276, PostgreSQLParserRULE_qual_all_op)
	p.SetState(9500)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetTokenStream().LA(1) {
	case PostgreSQLParserSTAR, PostgreSQLParserEQUAL, PostgreSQLParserPLUS, PostgreSQLParserMINUS, PostgreSQLParserSLASH, PostgreSQLParserCARET, PostgreSQLParserLT, PostgreSQLParserGT, PostgreSQLParserLESS_EQUALS, PostgreSQLParserGREATER_EQUALS, PostgreSQLParserNOT_EQUALS, PostgreSQLParserPERCENT, PostgreSQLParserOperator:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(9494)
			p.All_op()
		}

	case PostgreSQLParserOPERATOR:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(9495)
			p.Match(PostgreSQLParserOPERATOR)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(9496)
			p.Match(PostgreSQLParserOPEN_PAREN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(9497)
			p.Any_operator()
		}
		{
			p.SetState(9498)
			p.Match(PostgreSQLParserCLOSE_PAREN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	default:
		p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// ISubquery_OpContext is an interface to support dynamic dispatch.
type ISubquery_OpContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	All_op() IAll_opContext
	OPERATOR() antlr.TerminalNode
	OPEN_PAREN() antlr.TerminalNode
	Any_operator() IAny_operatorContext
	CLOSE_PAREN() antlr.TerminalNode
	LIKE() antlr.TerminalNode
	NOT() antlr.TerminalNode
	ILIKE() antlr.TerminalNode

	// IsSubquery_OpContext differentiates from other interfaces.
	IsSubquery_OpContext()
}

type Subquery_OpContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptySubquery_OpContext() *Subquery_OpContext {
	var p = new(Subquery_OpContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_subquery_Op
	return p
}

func InitEmptySubquery_OpContext(p *Subquery_OpContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_subquery_Op
}

func (*Subquery_OpContext) IsSubquery_OpContext() {}

func NewSubquery_OpContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Subquery_OpContext {
	var p = new(Subquery_OpContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_subquery_Op

	return p
}

func (s *Subquery_OpContext) GetParser() antlr.Parser { return s.parser }

func (s *Subquery_OpContext) All_op() IAll_opContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IAll_opContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IAll_opContext)
}

func (s *Subquery_OpContext) OPERATOR() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserOPERATOR, 0)
}

func (s *Subquery_OpContext) OPEN_PAREN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserOPEN_PAREN, 0)
}

func (s *Subquery_OpContext) Any_operator() IAny_operatorContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IAny_operatorContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IAny_operatorContext)
}

func (s *Subquery_OpContext) CLOSE_PAREN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCLOSE_PAREN, 0)
}

func (s *Subquery_OpContext) LIKE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserLIKE, 0)
}

func (s *Subquery_OpContext) NOT() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserNOT, 0)
}

func (s *Subquery_OpContext) ILIKE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserILIKE, 0)
}

func (s *Subquery_OpContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Subquery_OpContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Subquery_OpContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterSubquery_Op(s)
	}
}

func (s *Subquery_OpContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitSubquery_Op(s)
	}
}

func (s *Subquery_OpContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitSubquery_Op(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Subquery_Op() (localctx ISubquery_OpContext) {
	localctx = NewSubquery_OpContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1278, PostgreSQLParserRULE_subquery_Op)
	p.SetState(9514)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 617, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(9502)
			p.All_op()
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(9503)
			p.Match(PostgreSQLParserOPERATOR)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(9504)
			p.Match(PostgreSQLParserOPEN_PAREN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(9505)
			p.Any_operator()
		}
		{
			p.SetState(9506)
			p.Match(PostgreSQLParserCLOSE_PAREN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 3:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(9508)
			p.Match(PostgreSQLParserLIKE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 4:
		p.EnterOuterAlt(localctx, 4)
		{
			p.SetState(9509)
			p.Match(PostgreSQLParserNOT)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(9510)
			p.Match(PostgreSQLParserLIKE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 5:
		p.EnterOuterAlt(localctx, 5)
		{
			p.SetState(9511)
			p.Match(PostgreSQLParserILIKE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 6:
		p.EnterOuterAlt(localctx, 6)
		{
			p.SetState(9512)
			p.Match(PostgreSQLParserNOT)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(9513)
			p.Match(PostgreSQLParserILIKE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case antlr.ATNInvalidAltNumber:
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IExpr_listContext is an interface to support dynamic dispatch.
type IExpr_listContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	AllA_expr() []IA_exprContext
	A_expr(i int) IA_exprContext
	AllCOMMA() []antlr.TerminalNode
	COMMA(i int) antlr.TerminalNode

	// IsExpr_listContext differentiates from other interfaces.
	IsExpr_listContext()
}

type Expr_listContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyExpr_listContext() *Expr_listContext {
	var p = new(Expr_listContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_expr_list
	return p
}

func InitEmptyExpr_listContext(p *Expr_listContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_expr_list
}

func (*Expr_listContext) IsExpr_listContext() {}

func NewExpr_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Expr_listContext {
	var p = new(Expr_listContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_expr_list

	return p
}

func (s *Expr_listContext) GetParser() antlr.Parser { return s.parser }

func (s *Expr_listContext) AllA_expr() []IA_exprContext {
	children := s.GetChildren()
	len := 0
	for _, ctx := range children {
		if _, ok := ctx.(IA_exprContext); ok {
			len++
		}
	}

	tst := make([]IA_exprContext, len)
	i := 0
	for _, ctx := range children {
		if t, ok := ctx.(IA_exprContext); ok {
			tst[i] = t.(IA_exprContext)
			i++
		}
	}

	return tst
}

func (s *Expr_listContext) A_expr(i int) IA_exprContext {
	var t antlr.RuleContext
	j := 0
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IA_exprContext); ok {
			if j == i {
				t = ctx.(antlr.RuleContext)
				break
			}
			j++
		}
	}

	if t == nil {
		return nil
	}

	return t.(IA_exprContext)
}

func (s *Expr_listContext) AllCOMMA() []antlr.TerminalNode {
	return s.GetTokens(PostgreSQLParserCOMMA)
}

func (s *Expr_listContext) COMMA(i int) antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCOMMA, i)
}

func (s *Expr_listContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Expr_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Expr_listContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterExpr_list(s)
	}
}

func (s *Expr_listContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitExpr_list(s)
	}
}

func (s *Expr_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitExpr_list(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Expr_list() (localctx IExpr_listContext) {
	localctx = NewExpr_listContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1280, PostgreSQLParserRULE_expr_list)
	var _alt int

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(9516)
		p.A_expr()
	}
	p.SetState(9521)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}
	_alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 618, p.GetParserRuleContext())
	if p.HasError() {
		goto errorExit
	}
	for _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
		if _alt == 1 {
			{
				p.SetState(9517)
				p.Match(PostgreSQLParserCOMMA)
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}
			{
				p.SetState(9518)
				p.A_expr()
			}

		}
		p.SetState(9523)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}
		_alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 618, p.GetParserRuleContext())
		if p.HasError() {
			goto errorExit
		}
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IFunc_arg_listContext is an interface to support dynamic dispatch.
type IFunc_arg_listContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	AllFunc_arg_expr() []IFunc_arg_exprContext
	Func_arg_expr(i int) IFunc_arg_exprContext
	AllCOMMA() []antlr.TerminalNode
	COMMA(i int) antlr.TerminalNode

	// IsFunc_arg_listContext differentiates from other interfaces.
	IsFunc_arg_listContext()
}

type Func_arg_listContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyFunc_arg_listContext() *Func_arg_listContext {
	var p = new(Func_arg_listContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_func_arg_list
	return p
}

func InitEmptyFunc_arg_listContext(p *Func_arg_listContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_func_arg_list
}

func (*Func_arg_listContext) IsFunc_arg_listContext() {}

func NewFunc_arg_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Func_arg_listContext {
	var p = new(Func_arg_listContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_func_arg_list

	return p
}

func (s *Func_arg_listContext) GetParser() antlr.Parser { return s.parser }

func (s *Func_arg_listContext) AllFunc_arg_expr() []IFunc_arg_exprContext {
	children := s.GetChildren()
	len := 0
	for _, ctx := range children {
		if _, ok := ctx.(IFunc_arg_exprContext); ok {
			len++
		}
	}

	tst := make([]IFunc_arg_exprContext, len)
	i := 0
	for _, ctx := range children {
		if t, ok := ctx.(IFunc_arg_exprContext); ok {
			tst[i] = t.(IFunc_arg_exprContext)
			i++
		}
	}

	return tst
}

func (s *Func_arg_listContext) Func_arg_expr(i int) IFunc_arg_exprContext {
	var t antlr.RuleContext
	j := 0
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IFunc_arg_exprContext); ok {
			if j == i {
				t = ctx.(antlr.RuleContext)
				break
			}
			j++
		}
	}

	if t == nil {
		return nil
	}

	return t.(IFunc_arg_exprContext)
}

func (s *Func_arg_listContext) AllCOMMA() []antlr.TerminalNode {
	return s.GetTokens(PostgreSQLParserCOMMA)
}

func (s *Func_arg_listContext) COMMA(i int) antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCOMMA, i)
}

func (s *Func_arg_listContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Func_arg_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Func_arg_listContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterFunc_arg_list(s)
	}
}

func (s *Func_arg_listContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitFunc_arg_list(s)
	}
}

func (s *Func_arg_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitFunc_arg_list(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Func_arg_list() (localctx IFunc_arg_listContext) {
	localctx = NewFunc_arg_listContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1282, PostgreSQLParserRULE_func_arg_list)
	var _alt int

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(9524)
		p.Func_arg_expr()
	}
	p.SetState(9529)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}
	_alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 619, p.GetParserRuleContext())
	if p.HasError() {
		goto errorExit
	}
	for _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
		if _alt == 1 {
			{
				p.SetState(9525)
				p.Match(PostgreSQLParserCOMMA)
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}
			{
				p.SetState(9526)
				p.Func_arg_expr()
			}

		}
		p.SetState(9531)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}
		_alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 619, p.GetParserRuleContext())
		if p.HasError() {
			goto errorExit
		}
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IFunc_arg_exprContext is an interface to support dynamic dispatch.
type IFunc_arg_exprContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	A_expr() IA_exprContext
	Param_name() IParam_nameContext
	COLON_EQUALS() antlr.TerminalNode
	EQUALS_GREATER() antlr.TerminalNode

	// IsFunc_arg_exprContext differentiates from other interfaces.
	IsFunc_arg_exprContext()
}

type Func_arg_exprContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyFunc_arg_exprContext() *Func_arg_exprContext {
	var p = new(Func_arg_exprContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_func_arg_expr
	return p
}

func InitEmptyFunc_arg_exprContext(p *Func_arg_exprContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_func_arg_expr
}

func (*Func_arg_exprContext) IsFunc_arg_exprContext() {}

func NewFunc_arg_exprContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Func_arg_exprContext {
	var p = new(Func_arg_exprContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_func_arg_expr

	return p
}

func (s *Func_arg_exprContext) GetParser() antlr.Parser { return s.parser }

func (s *Func_arg_exprContext) A_expr() IA_exprContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IA_exprContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IA_exprContext)
}

func (s *Func_arg_exprContext) Param_name() IParam_nameContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IParam_nameContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IParam_nameContext)
}

func (s *Func_arg_exprContext) COLON_EQUALS() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCOLON_EQUALS, 0)
}

func (s *Func_arg_exprContext) EQUALS_GREATER() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserEQUALS_GREATER, 0)
}

func (s *Func_arg_exprContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Func_arg_exprContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Func_arg_exprContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterFunc_arg_expr(s)
	}
}

func (s *Func_arg_exprContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitFunc_arg_expr(s)
	}
}

func (s *Func_arg_exprContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitFunc_arg_expr(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Func_arg_expr() (localctx IFunc_arg_exprContext) {
	localctx = NewFunc_arg_exprContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1284, PostgreSQLParserRULE_func_arg_expr)
	var _la int

	p.SetState(9537)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 620, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(9532)
			p.A_expr()
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(9533)
			p.Param_name()
		}
		{
			p.SetState(9534)
			_la = p.GetTokenStream().LA(1)

			if !(_la == PostgreSQLParserCOLON_EQUALS || _la == PostgreSQLParserEQUALS_GREATER) {
				p.GetErrorHandler().RecoverInline(p)
			} else {
				p.GetErrorHandler().ReportMatch(p)
				p.Consume()
			}
		}
		{
			p.SetState(9535)
			p.A_expr()
		}

	case antlr.ATNInvalidAltNumber:
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IType_listContext is an interface to support dynamic dispatch.
type IType_listContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	AllTypename() []ITypenameContext
	Typename(i int) ITypenameContext
	AllCOMMA() []antlr.TerminalNode
	COMMA(i int) antlr.TerminalNode

	// IsType_listContext differentiates from other interfaces.
	IsType_listContext()
}

type Type_listContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyType_listContext() *Type_listContext {
	var p = new(Type_listContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_type_list
	return p
}

func InitEmptyType_listContext(p *Type_listContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_type_list
}

func (*Type_listContext) IsType_listContext() {}

func NewType_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Type_listContext {
	var p = new(Type_listContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_type_list

	return p
}

func (s *Type_listContext) GetParser() antlr.Parser { return s.parser }

func (s *Type_listContext) AllTypename() []ITypenameContext {
	children := s.GetChildren()
	len := 0
	for _, ctx := range children {
		if _, ok := ctx.(ITypenameContext); ok {
			len++
		}
	}

	tst := make([]ITypenameContext, len)
	i := 0
	for _, ctx := range children {
		if t, ok := ctx.(ITypenameContext); ok {
			tst[i] = t.(ITypenameContext)
			i++
		}
	}

	return tst
}

func (s *Type_listContext) Typename(i int) ITypenameContext {
	var t antlr.RuleContext
	j := 0
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ITypenameContext); ok {
			if j == i {
				t = ctx.(antlr.RuleContext)
				break
			}
			j++
		}
	}

	if t == nil {
		return nil
	}

	return t.(ITypenameContext)
}

func (s *Type_listContext) AllCOMMA() []antlr.TerminalNode {
	return s.GetTokens(PostgreSQLParserCOMMA)
}

func (s *Type_listContext) COMMA(i int) antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCOMMA, i)
}

func (s *Type_listContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Type_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Type_listContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterType_list(s)
	}
}

func (s *Type_listContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitType_list(s)
	}
}

func (s *Type_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitType_list(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Type_list() (localctx IType_listContext) {
	localctx = NewType_listContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1286, PostgreSQLParserRULE_type_list)
	var _la int

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(9539)
		p.Typename()
	}
	p.SetState(9544)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}
	_la = p.GetTokenStream().LA(1)

	for _la == PostgreSQLParserCOMMA {
		{
			p.SetState(9540)
			p.Match(PostgreSQLParserCOMMA)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(9541)
			p.Typename()
		}

		p.SetState(9546)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}
		_la = p.GetTokenStream().LA(1)
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IArray_exprContext is an interface to support dynamic dispatch.
type IArray_exprContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	OPEN_BRACKET() antlr.TerminalNode
	CLOSE_BRACKET() antlr.TerminalNode
	Expr_list() IExpr_listContext
	Array_expr_list() IArray_expr_listContext

	// IsArray_exprContext differentiates from other interfaces.
	IsArray_exprContext()
}

type Array_exprContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyArray_exprContext() *Array_exprContext {
	var p = new(Array_exprContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_array_expr
	return p
}

func InitEmptyArray_exprContext(p *Array_exprContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_array_expr
}

func (*Array_exprContext) IsArray_exprContext() {}

func NewArray_exprContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Array_exprContext {
	var p = new(Array_exprContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_array_expr

	return p
}

func (s *Array_exprContext) GetParser() antlr.Parser { return s.parser }

func (s *Array_exprContext) OPEN_BRACKET() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserOPEN_BRACKET, 0)
}

func (s *Array_exprContext) CLOSE_BRACKET() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCLOSE_BRACKET, 0)
}

func (s *Array_exprContext) Expr_list() IExpr_listContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IExpr_listContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IExpr_listContext)
}

func (s *Array_exprContext) Array_expr_list() IArray_expr_listContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IArray_expr_listContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IArray_expr_listContext)
}

func (s *Array_exprContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Array_exprContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Array_exprContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterArray_expr(s)
	}
}

func (s *Array_exprContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitArray_expr(s)
	}
}

func (s *Array_exprContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitArray_expr(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Array_expr() (localctx IArray_exprContext) {
	localctx = NewArray_exprContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1288, PostgreSQLParserRULE_array_expr)
	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(9547)
		p.Match(PostgreSQLParserOPEN_BRACKET)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	p.SetState(9550)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}
	switch p.GetTokenStream().LA(1) {
	case PostgreSQLParserOPEN_PAREN, PostgreSQLParserPLUS, PostgreSQLParserMINUS, PostgreSQLParserPARAM, PostgreSQLParserOperator, PostgreSQLParserAND, PostgreSQLParserARRAY, PostgreSQLParserCASE, PostgreSQLParserCAST, PostgreSQLParserCOLLATE, PostgreSQLParserCOLUMN, PostgreSQLParserCONSTRAINT, PostgreSQLParserCURRENT_CATALOG, PostgreSQLParserCURRENT_DATE, PostgreSQLParserCURRENT_ROLE, PostgreSQLParserCURRENT_TIME, PostgreSQLParserCURRENT_TIMESTAMP, PostgreSQLParserCURRENT_USER, PostgreSQLParserDEFAULT, PostgreSQLParserDO, PostgreSQLParserFALSE_P, PostgreSQLParserFETCH, PostgreSQLParserLOCALTIME, PostgreSQLParserLOCALTIMESTAMP, PostgreSQLParserNOT, PostgreSQLParserNULL_P, PostgreSQLParserSESSION_USER, PostgreSQLParserTABLE, PostgreSQLParserTRUE_P, PostgreSQLParserUNIQUE, PostgreSQLParserUSER, PostgreSQLParserAUTHORIZATION, PostgreSQLParserBINARY, PostgreSQLParserCOLLATION, PostgreSQLParserCONCURRENTLY, PostgreSQLParserCROSS, PostgreSQLParserCURRENT_SCHEMA, PostgreSQLParserFREEZE, PostgreSQLParserFULL, PostgreSQLParserILIKE, PostgreSQLParserINNER_P, PostgreSQLParserIS, PostgreSQLParserISNULL, PostgreSQLParserJOIN, PostgreSQLParserLEFT, PostgreSQLParserLIKE, PostgreSQLParserNATURAL, PostgreSQLParserNOTNULL, PostgreSQLParserOUTER_P, PostgreSQLParserOVER, PostgreSQLParserOVERLAPS, PostgreSQLParserRIGHT, PostgreSQLParserSIMILAR, PostgreSQLParserVERBOSE, PostgreSQLParserABORT_P, PostgreSQLParserABSOLUTE_P, PostgreSQLParserACCESS, PostgreSQLParserACTION, PostgreSQLParserADD_P, PostgreSQLParserADMIN, PostgreSQLParserAFTER, PostgreSQLParserAGGREGATE, PostgreSQLParserALSO, PostgreSQLParserALTER, PostgreSQLParserALWAYS, PostgreSQLParserASSERTION, PostgreSQLParserASSIGNMENT, PostgreSQLParserAT, PostgreSQLParserATTRIBUTE, PostgreSQLParserBACKWARD, PostgreSQLParserBEFORE, PostgreSQLParserBEGIN_P, PostgreSQLParserBY, PostgreSQLParserCACHE, PostgreSQLParserCALLED, PostgreSQLParserCASCADE, PostgreSQLParserCASCADED, PostgreSQLParserCATALOG, PostgreSQLParserCHAIN, PostgreSQLParserCHARACTERISTICS, PostgreSQLParserCHECKPOINT, PostgreSQLParserCLASS, PostgreSQLParserCLOSE, PostgreSQLParserCLUSTER, PostgreSQLParserCOMMENT, PostgreSQLParserCOMMENTS, PostgreSQLParserCOMMIT, PostgreSQLParserCOMMITTED, PostgreSQLParserCONFIGURATION, PostgreSQLParserCONNECTION, PostgreSQLParserCONSTRAINTS, PostgreSQLParserCONTENT_P, PostgreSQLParserCONTINUE_P, PostgreSQLParserCONVERSION_P, PostgreSQLParserCOPY, PostgreSQLParserCOST, PostgreSQLParserCSV, PostgreSQLParserCURSOR, PostgreSQLParserCYCLE, PostgreSQLParserDATA_P, PostgreSQLParserDATABASE, PostgreSQLParserDAY_P, PostgreSQLParserDEALLOCATE, PostgreSQLParserDECLARE, PostgreSQLParserDEFAULTS, PostgreSQLParserDEFERRED, PostgreSQLParserDEFINER, PostgreSQLParserDELETE_P, PostgreSQLParserDELIMITER, PostgreSQLParserDELIMITERS, PostgreSQLParserDICTIONARY, PostgreSQLParserDISABLE_P, PostgreSQLParserDISCARD, PostgreSQLParserDOCUMENT_P, PostgreSQLParserDOMAIN_P, PostgreSQLParserDOUBLE_P, PostgreSQLParserDROP, PostgreSQLParserEACH, PostgreSQLParserENABLE_P, PostgreSQLParserENCODING, PostgreSQLParserENCRYPTED, PostgreSQLParserENUM_P, PostgreSQLParserESCAPE, PostgreSQLParserEVENT, PostgreSQLParserEXCLUDE, PostgreSQLParserEXCLUDING, PostgreSQLParserEXCLUSIVE, PostgreSQLParserEXECUTE, PostgreSQLParserEXPLAIN, PostgreSQLParserEXTENSION, PostgreSQLParserEXTERNAL, PostgreSQLParserFAMILY, PostgreSQLParserFIRST_P, PostgreSQLParserFOLLOWING, PostgreSQLParserFORCE, PostgreSQLParserFORWARD, PostgreSQLParserFUNCTION, PostgreSQLParserFUNCTIONS, PostgreSQLParserGLOBAL, PostgreSQLParserGRANTED, PostgreSQLParserHANDLER, PostgreSQLParserHEADER_P, PostgreSQLParserHOLD, PostgreSQLParserHOUR_P, PostgreSQLParserIDENTITY_P, PostgreSQLParserIF_P, PostgreSQLParserIMMEDIATE, PostgreSQLParserIMMUTABLE, PostgreSQLParserIMPLICIT_P, PostgreSQLParserINCLUDING, PostgreSQLParserINCREMENT, PostgreSQLParserINDEX, PostgreSQLParserINDEXES, PostgreSQLParserINHERIT, PostgreSQLParserINHERITS, PostgreSQLParserINLINE_P, PostgreSQLParserINSENSITIVE, PostgreSQLParserINSERT, PostgreSQLParserINSTEAD, PostgreSQLParserINVOKER, PostgreSQLParserISOLATION, PostgreSQLParserKEY, PostgreSQLParserLABEL, PostgreSQLParserLANGUAGE, PostgreSQLParserLARGE_P, PostgreSQLParserLAST_P, PostgreSQLParserLEAKPROOF, PostgreSQLParserLEVEL, PostgreSQLParserLISTEN, PostgreSQLParserLOAD, PostgreSQLParserLOCAL, PostgreSQLParserLOCATION, PostgreSQLParserLOCK_P, PostgreSQLParserMAPPING, PostgreSQLParserMATCH, PostgreSQLParserMATERIALIZED, PostgreSQLParserMAXVALUE, PostgreSQLParserMINUTE_P, PostgreSQLParserMINVALUE, PostgreSQLParserMODE, PostgreSQLParserMONTH_P, PostgreSQLParserMOVE, PostgreSQLParserNAME_P, PostgreSQLParserNAMES, PostgreSQLParserNEXT, PostgreSQLParserNO, PostgreSQLParserNOTHING, PostgreSQLParserNOTIFY, PostgreSQLParserNOWAIT, PostgreSQLParserNULLS_P, PostgreSQLParserOBJECT_P, PostgreSQLParserOF, PostgreSQLParserOFF, PostgreSQLParserOIDS, PostgreSQLParserOPERATOR, PostgreSQLParserOPTION, PostgreSQLParserOPTIONS, PostgreSQLParserOWNED, PostgreSQLParserOWNER, PostgreSQLParserPARSER, PostgreSQLParserPARTIAL, PostgreSQLParserPARTITION, PostgreSQLParserPASSING, PostgreSQLParserPASSWORD, PostgreSQLParserPLANS, PostgreSQLParserPRECEDING, PostgreSQLParserPREPARE, PostgreSQLParserPREPARED, PostgreSQLParserPRESERVE, PostgreSQLParserPRIOR, PostgreSQLParserPRIVILEGES, PostgreSQLParserPROCEDURAL, PostgreSQLParserPROCEDURE, PostgreSQLParserPROGRAM, PostgreSQLParserQUOTE, PostgreSQLParserRANGE, PostgreSQLParserREAD, PostgreSQLParserREASSIGN, PostgreSQLParserRECHECK, PostgreSQLParserRECURSIVE, PostgreSQLParserREF, PostgreSQLParserREFRESH, PostgreSQLParserREINDEX, PostgreSQLParserRELATIVE_P, PostgreSQLParserRELEASE, PostgreSQLParserRENAME, PostgreSQLParserREPEATABLE, PostgreSQLParserREPLACE, PostgreSQLParserREPLICA, PostgreSQLParserRESET, PostgreSQLParserRESTART, PostgreSQLParserRESTRICT, PostgreSQLParserRETURNS, PostgreSQLParserREVOKE, PostgreSQLParserROLE, PostgreSQLParserROLLBACK, PostgreSQLParserROWS, PostgreSQLParserRULE, PostgreSQLParserSAVEPOINT, PostgreSQLParserSCHEMA, PostgreSQLParserSCROLL, PostgreSQLParserSEARCH, PostgreSQLParserSECOND_P, PostgreSQLParserSECURITY, PostgreSQLParserSEQUENCE, PostgreSQLParserSEQUENCES, PostgreSQLParserSERIALIZABLE, PostgreSQLParserSERVER, PostgreSQLParserSESSION, PostgreSQLParserSET, PostgreSQLParserSHARE, PostgreSQLParserSHOW, PostgreSQLParserSIMPLE, PostgreSQLParserSNAPSHOT, PostgreSQLParserSTABLE, PostgreSQLParserSTANDALONE_P, PostgreSQLParserSTART, PostgreSQLParserSTATEMENT, PostgreSQLParserSTATISTICS, PostgreSQLParserSTDIN, PostgreSQLParserSTDOUT, PostgreSQLParserSTORAGE, PostgreSQLParserSTRICT_P, PostgreSQLParserSTRIP_P, PostgreSQLParserSYSID, PostgreSQLParserSYSTEM_P, PostgreSQLParserTABLES, PostgreSQLParserTABLESPACE, PostgreSQLParserTEMP, PostgreSQLParserTEMPLATE, PostgreSQLParserTEMPORARY, PostgreSQLParserTEXT_P, PostgreSQLParserTRANSACTION, PostgreSQLParserTRIGGER, PostgreSQLParserTRUNCATE, PostgreSQLParserTRUSTED, PostgreSQLParserTYPE_P, PostgreSQLParserTYPES_P, PostgreSQLParserUNBOUNDED, PostgreSQLParserUNCOMMITTED, PostgreSQLParserUNENCRYPTED, PostgreSQLParserUNKNOWN, PostgreSQLParserUNLISTEN, PostgreSQLParserUNLOGGED, PostgreSQLParserUNTIL, PostgreSQLParserUPDATE, PostgreSQLParserVACUUM, PostgreSQLParserVALID, PostgreSQLParserVALIDATE, PostgreSQLParserVALIDATOR, PostgreSQLParserVARYING, PostgreSQLParserVERSION_P, PostgreSQLParserVIEW, PostgreSQLParserVOLATILE, PostgreSQLParserWHITESPACE_P, PostgreSQLParserWITHOUT, PostgreSQLParserWORK, PostgreSQLParserWRAPPER, PostgreSQLParserWRITE, PostgreSQLParserXML_P, PostgreSQLParserYEAR_P, PostgreSQLParserYES_P, PostgreSQLParserZONE, PostgreSQLParserBETWEEN, PostgreSQLParserBIGINT, PostgreSQLParserBIT, PostgreSQLParserBOOLEAN_P, PostgreSQLParserCHAR_P, PostgreSQLParserCHARACTER, PostgreSQLParserCOALESCE, PostgreSQLParserDEC, PostgreSQLParserDECIMAL_P, PostgreSQLParserEXISTS, PostgreSQLParserEXTRACT, PostgreSQLParserFLOAT_P, PostgreSQLParserGREATEST, PostgreSQLParserINOUT, PostgreSQLParserINT_P, PostgreSQLParserINTEGER, PostgreSQLParserINTERVAL, PostgreSQLParserLEAST, PostgreSQLParserNATIONAL, PostgreSQLParserNCHAR, PostgreSQLParserNONE, PostgreSQLParserNULLIF, PostgreSQLParserNUMERIC, PostgreSQLParserOVERLAY, PostgreSQLParserPOSITION, PostgreSQLParserPRECISION, PostgreSQLParserREAL, PostgreSQLParserROW, PostgreSQLParserSETOF, PostgreSQLParserSMALLINT, PostgreSQLParserSUBSTRING, PostgreSQLParserTIME, PostgreSQLParserTIMESTAMP, PostgreSQLParserTREAT, PostgreSQLParserTRIM, PostgreSQLParserVALUES, PostgreSQLParserVARCHAR, PostgreSQLParserXMLATTRIBUTES, PostgreSQLParserXMLCOMMENT, PostgreSQLParserXMLAGG, PostgreSQLParserXML_IS_WELL_FORMED, PostgreSQLParserXML_IS_WELL_FORMED_DOCUMENT, PostgreSQLParserXML_IS_WELL_FORMED_CONTENT, PostgreSQLParserXPATH, PostgreSQLParserXPATH_EXISTS, PostgreSQLParserXMLCONCAT, PostgreSQLParserXMLELEMENT, PostgreSQLParserXMLEXISTS, PostgreSQLParserXMLFOREST, PostgreSQLParserXMLPARSE, PostgreSQLParserXMLPI, PostgreSQLParserXMLROOT, PostgreSQLParserXMLSERIALIZE, PostgreSQLParserCALL, PostgreSQLParserCURRENT_P, PostgreSQLParserATTACH, PostgreSQLParserDETACH, PostgreSQLParserEXPRESSION, PostgreSQLParserGENERATED, PostgreSQLParserLOGGED, PostgreSQLParserSTORED, PostgreSQLParserINCLUDE, PostgreSQLParserROUTINE, PostgreSQLParserTRANSFORM, PostgreSQLParserIMPORT_P, PostgreSQLParserPOLICY, PostgreSQLParserMETHOD, PostgreSQLParserREFERENCING, PostgreSQLParserNEW, PostgreSQLParserOLD, PostgreSQLParserVALUE_P, PostgreSQLParserSUBSCRIPTION, PostgreSQLParserPUBLICATION, PostgreSQLParserOUT_P, PostgreSQLParserROUTINES, PostgreSQLParserSCHEMAS, PostgreSQLParserPROCEDURES, PostgreSQLParserINPUT_P, PostgreSQLParserSUPPORT, PostgreSQLParserPARALLEL, PostgreSQLParserSQL_P, PostgreSQLParserDEPENDS, PostgreSQLParserOVERRIDING, PostgreSQLParserCONFLICT, PostgreSQLParserSKIP_P, PostgreSQLParserLOCKED, PostgreSQLParserTIES, PostgreSQLParserROLLUP, PostgreSQLParserCUBE, PostgreSQLParserGROUPING, PostgreSQLParserSETS, PostgreSQLParserTABLESAMPLE, PostgreSQLParserORDINALITY, PostgreSQLParserXMLTABLE, PostgreSQLParserCOLUMNS, PostgreSQLParserXMLNAMESPACES, PostgreSQLParserROWTYPE, PostgreSQLParserNORMALIZED, PostgreSQLParserWITHIN, PostgreSQLParserFILTER, PostgreSQLParserGROUPS, PostgreSQLParserOTHERS, PostgreSQLParserNFC, PostgreSQLParserNFD, PostgreSQLParserNFKC, PostgreSQLParserNFKD, PostgreSQLParserUESCAPE, PostgreSQLParserVIEWS, PostgreSQLParserNORMALIZE, PostgreSQLParserDUMP, PostgreSQLParserPRINT_STRICT_PARAMS, PostgreSQLParserVARIABLE_CONFLICT, PostgreSQLParserERROR, PostgreSQLParserUSE_VARIABLE, PostgreSQLParserUSE_COLUMN, PostgreSQLParserALIAS, PostgreSQLParserCONSTANT, PostgreSQLParserPERFORM, PostgreSQLParserGET, PostgreSQLParserDIAGNOSTICS, PostgreSQLParserSTACKED, PostgreSQLParserELSIF, PostgreSQLParserREVERSE, PostgreSQLParserSLICE, PostgreSQLParserEXIT, PostgreSQLParserRETURN, PostgreSQLParserQUERY, PostgreSQLParserRAISE, PostgreSQLParserSQLSTATE, PostgreSQLParserDEBUG, PostgreSQLParserLOG, PostgreSQLParserINFO, PostgreSQLParserNOTICE, PostgreSQLParserWARNING, PostgreSQLParserEXCEPTION, PostgreSQLParserASSERT, PostgreSQLParserOPEN, PostgreSQLParserABS, PostgreSQLParserCBRT, PostgreSQLParserCEIL, PostgreSQLParserCEILING, PostgreSQLParserDEGREES, PostgreSQLParserDIV, PostgreSQLParserEXP, PostgreSQLParserFACTORIAL, PostgreSQLParserFLOOR, PostgreSQLParserGCD, PostgreSQLParserLCM, PostgreSQLParserLN, PostgreSQLParserLOG10, PostgreSQLParserMIN_SCALE, PostgreSQLParserMOD, PostgreSQLParserPI, PostgreSQLParserPOWER, PostgreSQLParserRADIANS, PostgreSQLParserROUND, PostgreSQLParserSCALE, PostgreSQLParserSIGN, PostgreSQLParserSQRT, PostgreSQLParserTRIM_SCALE, PostgreSQLParserTRUNC, PostgreSQLParserWIDTH_BUCKET, PostgreSQLParserRANDOM, PostgreSQLParserSETSEED, PostgreSQLParserACOS, PostgreSQLParserACOSD, PostgreSQLParserASIN, PostgreSQLParserASIND, PostgreSQLParserATAN, PostgreSQLParserATAND, PostgreSQLParserATAN2, PostgreSQLParserATAN2D, PostgreSQLParserCOS, PostgreSQLParserCOSD, PostgreSQLParserCOT, PostgreSQLParserCOTD, PostgreSQLParserSIN, PostgreSQLParserSIND, PostgreSQLParserTAN, PostgreSQLParserTAND, PostgreSQLParserSINH, PostgreSQLParserCOSH, PostgreSQLParserTANH, PostgreSQLParserASINH, PostgreSQLParserACOSH, PostgreSQLParserATANH, PostgreSQLParserBIT_LENGTH, PostgreSQLParserCHAR_LENGTH, PostgreSQLParserCHARACTER_LENGTH, PostgreSQLParserLOWER, PostgreSQLParserOCTET_LENGTH, PostgreSQLParserUPPER, PostgreSQLParserASCII, PostgreSQLParserBTRIM, PostgreSQLParserCHR, PostgreSQLParserCONCAT, PostgreSQLParserCONCAT_WS, PostgreSQLParserFORMAT, PostgreSQLParserINITCAP, PostgreSQLParserLENGTH, PostgreSQLParserLPAD, PostgreSQLParserLTRIM, PostgreSQLParserMD5, PostgreSQLParserPARSE_IDENT, PostgreSQLParserPG_CLIENT_ENCODING, PostgreSQLParserQUOTE_IDENT, PostgreSQLParserQUOTE_LITERAL, PostgreSQLParserQUOTE_NULLABLE, PostgreSQLParserREGEXP_COUNT, PostgreSQLParserREGEXP_INSTR, PostgreSQLParserREGEXP_LIKE, PostgreSQLParserREGEXP_MATCH, PostgreSQLParserREGEXP_MATCHES, PostgreSQLParserREGEXP_REPLACE, PostgreSQLParserREGEXP_SPLIT_TO_ARRAY, PostgreSQLParserREGEXP_SPLIT_TO_TABLE, PostgreSQLParserREGEXP_SUBSTR, PostgreSQLParserREPEAT, PostgreSQLParserRPAD, PostgreSQLParserRTRIM, PostgreSQLParserSPLIT_PART, PostgreSQLParserSTARTS_WITH, PostgreSQLParserSTRING_TO_ARRAY, PostgreSQLParserSTRING_TO_TABLE, PostgreSQLParserSTRPOS, PostgreSQLParserSUBSTR, PostgreSQLParserTO_ASCII, PostgreSQLParserTO_HEX, PostgreSQLParserTRANSLATE, PostgreSQLParserUNISTR, PostgreSQLParserAGE, PostgreSQLParserCLOCK_TIMESTAMP, PostgreSQLParserDATE_BIN, PostgreSQLParserDATE_PART, PostgreSQLParserDATE_TRUNC, PostgreSQLParserISFINITE, PostgreSQLParserJUSTIFY_DAYS, PostgreSQLParserJUSTIFY_HOURS, PostgreSQLParserJUSTIFY_INTERVAL, PostgreSQLParserMAKE_DATE, PostgreSQLParserMAKE_INTERVAL, PostgreSQLParserMAKE_TIME, PostgreSQLParserMAKE_TIMESTAMP, PostgreSQLParserMAKE_TIMESTAMPTZ, PostgreSQLParserNOW, PostgreSQLParserSTATEMENT_TIMESTAMP, PostgreSQLParserTIMEOFDAY, PostgreSQLParserTRANSACTION_TIMESTAMP, PostgreSQLParserTO_TIMESTAMP, PostgreSQLParserTO_CHAR, PostgreSQLParserTO_DATE, PostgreSQLParserTO_NUMBER, PostgreSQLParserIdentifier, PostgreSQLParserQuotedIdentifier, PostgreSQLParserUnicodeQuotedIdentifier, PostgreSQLParserStringConstant, PostgreSQLParserUnicodeEscapeStringConstant, PostgreSQLParserBeginDollarStringConstant, PostgreSQLParserBinaryStringConstant, PostgreSQLParserHexadecimalStringConstant, PostgreSQLParserIntegral, PostgreSQLParserNumeric, PostgreSQLParserPLSQLVARIABLENAME, PostgreSQLParserPLSQLIDENTIFIER, PostgreSQLParserEscapeStringConstant:
		{
			p.SetState(9548)
			p.Expr_list()
		}

	case PostgreSQLParserOPEN_BRACKET:
		{
			p.SetState(9549)
			p.Array_expr_list()
		}

	case PostgreSQLParserCLOSE_BRACKET:

	default:
	}
	{
		p.SetState(9552)
		p.Match(PostgreSQLParserCLOSE_BRACKET)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IArray_expr_listContext is an interface to support dynamic dispatch.
type IArray_expr_listContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	AllArray_expr() []IArray_exprContext
	Array_expr(i int) IArray_exprContext
	AllCOMMA() []antlr.TerminalNode
	COMMA(i int) antlr.TerminalNode

	// IsArray_expr_listContext differentiates from other interfaces.
	IsArray_expr_listContext()
}

type Array_expr_listContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyArray_expr_listContext() *Array_expr_listContext {
	var p = new(Array_expr_listContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_array_expr_list
	return p
}

func InitEmptyArray_expr_listContext(p *Array_expr_listContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_array_expr_list
}

func (*Array_expr_listContext) IsArray_expr_listContext() {}

func NewArray_expr_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Array_expr_listContext {
	var p = new(Array_expr_listContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_array_expr_list

	return p
}

func (s *Array_expr_listContext) GetParser() antlr.Parser { return s.parser }

func (s *Array_expr_listContext) AllArray_expr() []IArray_exprContext {
	children := s.GetChildren()
	len := 0
	for _, ctx := range children {
		if _, ok := ctx.(IArray_exprContext); ok {
			len++
		}
	}

	tst := make([]IArray_exprContext, len)
	i := 0
	for _, ctx := range children {
		if t, ok := ctx.(IArray_exprContext); ok {
			tst[i] = t.(IArray_exprContext)
			i++
		}
	}

	return tst
}

func (s *Array_expr_listContext) Array_expr(i int) IArray_exprContext {
	var t antlr.RuleContext
	j := 0
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IArray_exprContext); ok {
			if j == i {
				t = ctx.(antlr.RuleContext)
				break
			}
			j++
		}
	}

	if t == nil {
		return nil
	}

	return t.(IArray_exprContext)
}

func (s *Array_expr_listContext) AllCOMMA() []antlr.TerminalNode {
	return s.GetTokens(PostgreSQLParserCOMMA)
}

func (s *Array_expr_listContext) COMMA(i int) antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCOMMA, i)
}

func (s *Array_expr_listContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Array_expr_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Array_expr_listContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterArray_expr_list(s)
	}
}

func (s *Array_expr_listContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitArray_expr_list(s)
	}
}

func (s *Array_expr_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitArray_expr_list(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Array_expr_list() (localctx IArray_expr_listContext) {
	localctx = NewArray_expr_listContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1290, PostgreSQLParserRULE_array_expr_list)
	var _la int

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(9554)
		p.Array_expr()
	}
	p.SetState(9559)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}
	_la = p.GetTokenStream().LA(1)

	for _la == PostgreSQLParserCOMMA {
		{
			p.SetState(9555)
			p.Match(PostgreSQLParserCOMMA)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(9556)
			p.Array_expr()
		}

		p.SetState(9561)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}
		_la = p.GetTokenStream().LA(1)
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IExtract_listContext is an interface to support dynamic dispatch.
type IExtract_listContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Extract_arg() IExtract_argContext
	FROM() antlr.TerminalNode
	A_expr() IA_exprContext

	// IsExtract_listContext differentiates from other interfaces.
	IsExtract_listContext()
}

type Extract_listContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyExtract_listContext() *Extract_listContext {
	var p = new(Extract_listContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_extract_list
	return p
}

func InitEmptyExtract_listContext(p *Extract_listContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_extract_list
}

func (*Extract_listContext) IsExtract_listContext() {}

func NewExtract_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Extract_listContext {
	var p = new(Extract_listContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_extract_list

	return p
}

func (s *Extract_listContext) GetParser() antlr.Parser { return s.parser }

func (s *Extract_listContext) Extract_arg() IExtract_argContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IExtract_argContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IExtract_argContext)
}

func (s *Extract_listContext) FROM() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserFROM, 0)
}

func (s *Extract_listContext) A_expr() IA_exprContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IA_exprContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IA_exprContext)
}

func (s *Extract_listContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Extract_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Extract_listContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterExtract_list(s)
	}
}

func (s *Extract_listContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitExtract_list(s)
	}
}

func (s *Extract_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitExtract_list(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Extract_list() (localctx IExtract_listContext) {
	localctx = NewExtract_listContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1292, PostgreSQLParserRULE_extract_list)
	p.SetState(9567)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetTokenStream().LA(1) {
	case PostgreSQLParserAND, PostgreSQLParserARRAY, PostgreSQLParserCOLLATE, PostgreSQLParserCOLUMN, PostgreSQLParserCONSTRAINT, PostgreSQLParserDEFAULT, PostgreSQLParserDO, PostgreSQLParserFETCH, PostgreSQLParserTABLE, PostgreSQLParserIS, PostgreSQLParserOUTER_P, PostgreSQLParserABSOLUTE_P, PostgreSQLParserBACKWARD, PostgreSQLParserCHAIN, PostgreSQLParserCLOSE, PostgreSQLParserCOMMIT, PostgreSQLParserCONTINUE_P, PostgreSQLParserCURSOR, PostgreSQLParserDAY_P, PostgreSQLParserFIRST_P, PostgreSQLParserFORWARD, PostgreSQLParserHOUR_P, PostgreSQLParserINSERT, PostgreSQLParserLAST_P, PostgreSQLParserMINUTE_P, PostgreSQLParserMONTH_P, PostgreSQLParserMOVE, PostgreSQLParserNEXT, PostgreSQLParserNO, PostgreSQLParserOPTION, PostgreSQLParserPRIOR, PostgreSQLParserRELATIVE_P, PostgreSQLParserRESET, PostgreSQLParserROLLBACK, PostgreSQLParserSCHEMA, PostgreSQLParserSCROLL, PostgreSQLParserSECOND_P, PostgreSQLParserSET, PostgreSQLParserTYPE_P, PostgreSQLParserYEAR_P, PostgreSQLParserCALL, PostgreSQLParserCURRENT_P, PostgreSQLParserROWTYPE, PostgreSQLParserDUMP, PostgreSQLParserPRINT_STRICT_PARAMS, PostgreSQLParserVARIABLE_CONFLICT, PostgreSQLParserERROR, PostgreSQLParserUSE_VARIABLE, PostgreSQLParserUSE_COLUMN, PostgreSQLParserALIAS, PostgreSQLParserCONSTANT, PostgreSQLParserPERFORM, PostgreSQLParserGET, PostgreSQLParserDIAGNOSTICS, PostgreSQLParserSTACKED, PostgreSQLParserELSIF, PostgreSQLParserSLICE, PostgreSQLParserEXIT, PostgreSQLParserRETURN, PostgreSQLParserQUERY, PostgreSQLParserRAISE, PostgreSQLParserSQLSTATE, PostgreSQLParserDEBUG, PostgreSQLParserINFO, PostgreSQLParserNOTICE, PostgreSQLParserWARNING, PostgreSQLParserEXCEPTION, PostgreSQLParserASSERT, PostgreSQLParserOPEN, PostgreSQLParserIdentifier, PostgreSQLParserQuotedIdentifier, PostgreSQLParserUnicodeQuotedIdentifier, PostgreSQLParserStringConstant, PostgreSQLParserUnicodeEscapeStringConstant, PostgreSQLParserBeginDollarStringConstant, PostgreSQLParserPLSQLVARIABLENAME, PostgreSQLParserPLSQLIDENTIFIER, PostgreSQLParserEscapeStringConstant:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(9562)
			p.Extract_arg()
		}
		{
			p.SetState(9563)
			p.Match(PostgreSQLParserFROM)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(9564)
			p.A_expr()
		}

	case PostgreSQLParserCLOSE_PAREN:
		p.EnterOuterAlt(localctx, 2)

	default:
		p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IExtract_argContext is an interface to support dynamic dispatch.
type IExtract_argContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Identifier() IIdentifierContext
	YEAR_P() antlr.TerminalNode
	MONTH_P() antlr.TerminalNode
	DAY_P() antlr.TerminalNode
	HOUR_P() antlr.TerminalNode
	MINUTE_P() antlr.TerminalNode
	SECOND_P() antlr.TerminalNode
	Sconst() ISconstContext

	// IsExtract_argContext differentiates from other interfaces.
	IsExtract_argContext()
}

type Extract_argContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyExtract_argContext() *Extract_argContext {
	var p = new(Extract_argContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_extract_arg
	return p
}

func InitEmptyExtract_argContext(p *Extract_argContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_extract_arg
}

func (*Extract_argContext) IsExtract_argContext() {}

func NewExtract_argContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Extract_argContext {
	var p = new(Extract_argContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_extract_arg

	return p
}

func (s *Extract_argContext) GetParser() antlr.Parser { return s.parser }

func (s *Extract_argContext) Identifier() IIdentifierContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IIdentifierContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IIdentifierContext)
}

func (s *Extract_argContext) YEAR_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserYEAR_P, 0)
}

func (s *Extract_argContext) MONTH_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserMONTH_P, 0)
}

func (s *Extract_argContext) DAY_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserDAY_P, 0)
}

func (s *Extract_argContext) HOUR_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserHOUR_P, 0)
}

func (s *Extract_argContext) MINUTE_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserMINUTE_P, 0)
}

func (s *Extract_argContext) SECOND_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserSECOND_P, 0)
}

func (s *Extract_argContext) Sconst() ISconstContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ISconstContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ISconstContext)
}

func (s *Extract_argContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Extract_argContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Extract_argContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterExtract_arg(s)
	}
}

func (s *Extract_argContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitExtract_arg(s)
	}
}

func (s *Extract_argContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitExtract_arg(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Extract_arg() (localctx IExtract_argContext) {
	localctx = NewExtract_argContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1294, PostgreSQLParserRULE_extract_arg)
	p.SetState(9577)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetTokenStream().LA(1) {
	case PostgreSQLParserAND, PostgreSQLParserARRAY, PostgreSQLParserCOLLATE, PostgreSQLParserCOLUMN, PostgreSQLParserCONSTRAINT, PostgreSQLParserDEFAULT, PostgreSQLParserDO, PostgreSQLParserFETCH, PostgreSQLParserTABLE, PostgreSQLParserIS, PostgreSQLParserOUTER_P, PostgreSQLParserABSOLUTE_P, PostgreSQLParserBACKWARD, PostgreSQLParserCHAIN, PostgreSQLParserCLOSE, PostgreSQLParserCOMMIT, PostgreSQLParserCONTINUE_P, PostgreSQLParserCURSOR, PostgreSQLParserFIRST_P, PostgreSQLParserFORWARD, PostgreSQLParserINSERT, PostgreSQLParserLAST_P, PostgreSQLParserMOVE, PostgreSQLParserNEXT, PostgreSQLParserNO, PostgreSQLParserOPTION, PostgreSQLParserPRIOR, PostgreSQLParserRELATIVE_P, PostgreSQLParserRESET, PostgreSQLParserROLLBACK, PostgreSQLParserSCHEMA, PostgreSQLParserSCROLL, PostgreSQLParserSET, PostgreSQLParserTYPE_P, PostgreSQLParserCALL, PostgreSQLParserCURRENT_P, PostgreSQLParserROWTYPE, PostgreSQLParserDUMP, PostgreSQLParserPRINT_STRICT_PARAMS, PostgreSQLParserVARIABLE_CONFLICT, PostgreSQLParserERROR, PostgreSQLParserUSE_VARIABLE, PostgreSQLParserUSE_COLUMN, PostgreSQLParserALIAS, PostgreSQLParserCONSTANT, PostgreSQLParserPERFORM, PostgreSQLParserGET, PostgreSQLParserDIAGNOSTICS, PostgreSQLParserSTACKED, PostgreSQLParserELSIF, PostgreSQLParserSLICE, PostgreSQLParserEXIT, PostgreSQLParserRETURN, PostgreSQLParserQUERY, PostgreSQLParserRAISE, PostgreSQLParserSQLSTATE, PostgreSQLParserDEBUG, PostgreSQLParserINFO, PostgreSQLParserNOTICE, PostgreSQLParserWARNING, PostgreSQLParserEXCEPTION, PostgreSQLParserASSERT, PostgreSQLParserOPEN, PostgreSQLParserIdentifier, PostgreSQLParserQuotedIdentifier, PostgreSQLParserUnicodeQuotedIdentifier, PostgreSQLParserPLSQLVARIABLENAME, PostgreSQLParserPLSQLIDENTIFIER:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(9569)
			p.Identifier()
		}

	case PostgreSQLParserYEAR_P:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(9570)
			p.Match(PostgreSQLParserYEAR_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case PostgreSQLParserMONTH_P:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(9571)
			p.Match(PostgreSQLParserMONTH_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case PostgreSQLParserDAY_P:
		p.EnterOuterAlt(localctx, 4)
		{
			p.SetState(9572)
			p.Match(PostgreSQLParserDAY_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case PostgreSQLParserHOUR_P:
		p.EnterOuterAlt(localctx, 5)
		{
			p.SetState(9573)
			p.Match(PostgreSQLParserHOUR_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case PostgreSQLParserMINUTE_P:
		p.EnterOuterAlt(localctx, 6)
		{
			p.SetState(9574)
			p.Match(PostgreSQLParserMINUTE_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case PostgreSQLParserSECOND_P:
		p.EnterOuterAlt(localctx, 7)
		{
			p.SetState(9575)
			p.Match(PostgreSQLParserSECOND_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case PostgreSQLParserStringConstant, PostgreSQLParserUnicodeEscapeStringConstant, PostgreSQLParserBeginDollarStringConstant, PostgreSQLParserEscapeStringConstant:
		p.EnterOuterAlt(localctx, 8)
		{
			p.SetState(9576)
			p.Sconst()
		}

	default:
		p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IUnicode_normal_formContext is an interface to support dynamic dispatch.
type IUnicode_normal_formContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	NFC() antlr.TerminalNode
	NFD() antlr.TerminalNode
	NFKC() antlr.TerminalNode
	NFKD() antlr.TerminalNode

	// IsUnicode_normal_formContext differentiates from other interfaces.
	IsUnicode_normal_formContext()
}

type Unicode_normal_formContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyUnicode_normal_formContext() *Unicode_normal_formContext {
	var p = new(Unicode_normal_formContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_unicode_normal_form
	return p
}

func InitEmptyUnicode_normal_formContext(p *Unicode_normal_formContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_unicode_normal_form
}

func (*Unicode_normal_formContext) IsUnicode_normal_formContext() {}

func NewUnicode_normal_formContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Unicode_normal_formContext {
	var p = new(Unicode_normal_formContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_unicode_normal_form

	return p
}

func (s *Unicode_normal_formContext) GetParser() antlr.Parser { return s.parser }

func (s *Unicode_normal_formContext) NFC() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserNFC, 0)
}

func (s *Unicode_normal_formContext) NFD() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserNFD, 0)
}

func (s *Unicode_normal_formContext) NFKC() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserNFKC, 0)
}

func (s *Unicode_normal_formContext) NFKD() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserNFKD, 0)
}

func (s *Unicode_normal_formContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Unicode_normal_formContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Unicode_normal_formContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterUnicode_normal_form(s)
	}
}

func (s *Unicode_normal_formContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitUnicode_normal_form(s)
	}
}

func (s *Unicode_normal_formContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitUnicode_normal_form(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Unicode_normal_form() (localctx IUnicode_normal_formContext) {
	localctx = NewUnicode_normal_formContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1296, PostgreSQLParserRULE_unicode_normal_form)
	var _la int

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(9579)
		_la = p.GetTokenStream().LA(1)

		if !((int64((_la-483)) & ^0x3f) == 0 && ((int64(1)<<(_la-483))&15) != 0) {
			p.GetErrorHandler().RecoverInline(p)
		} else {
			p.GetErrorHandler().ReportMatch(p)
			p.Consume()
		}
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IOverlay_listContext is an interface to support dynamic dispatch.
type IOverlay_listContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	AllA_expr() []IA_exprContext
	A_expr(i int) IA_exprContext
	PLACING() antlr.TerminalNode
	FROM() antlr.TerminalNode
	FOR() antlr.TerminalNode

	// IsOverlay_listContext differentiates from other interfaces.
	IsOverlay_listContext()
}

type Overlay_listContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyOverlay_listContext() *Overlay_listContext {
	var p = new(Overlay_listContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_overlay_list
	return p
}

func InitEmptyOverlay_listContext(p *Overlay_listContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_overlay_list
}

func (*Overlay_listContext) IsOverlay_listContext() {}

func NewOverlay_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Overlay_listContext {
	var p = new(Overlay_listContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_overlay_list

	return p
}

func (s *Overlay_listContext) GetParser() antlr.Parser { return s.parser }

func (s *Overlay_listContext) AllA_expr() []IA_exprContext {
	children := s.GetChildren()
	len := 0
	for _, ctx := range children {
		if _, ok := ctx.(IA_exprContext); ok {
			len++
		}
	}

	tst := make([]IA_exprContext, len)
	i := 0
	for _, ctx := range children {
		if t, ok := ctx.(IA_exprContext); ok {
			tst[i] = t.(IA_exprContext)
			i++
		}
	}

	return tst
}

func (s *Overlay_listContext) A_expr(i int) IA_exprContext {
	var t antlr.RuleContext
	j := 0
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IA_exprContext); ok {
			if j == i {
				t = ctx.(antlr.RuleContext)
				break
			}
			j++
		}
	}

	if t == nil {
		return nil
	}

	return t.(IA_exprContext)
}

func (s *Overlay_listContext) PLACING() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserPLACING, 0)
}

func (s *Overlay_listContext) FROM() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserFROM, 0)
}

func (s *Overlay_listContext) FOR() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserFOR, 0)
}

func (s *Overlay_listContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Overlay_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Overlay_listContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterOverlay_list(s)
	}
}

func (s *Overlay_listContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitOverlay_list(s)
	}
}

func (s *Overlay_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitOverlay_list(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Overlay_list() (localctx IOverlay_listContext) {
	localctx = NewOverlay_listContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1298, PostgreSQLParserRULE_overlay_list)
	var _la int

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(9581)
		p.A_expr()
	}
	{
		p.SetState(9582)
		p.Match(PostgreSQLParserPLACING)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(9583)
		p.A_expr()
	}
	{
		p.SetState(9584)
		p.Match(PostgreSQLParserFROM)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(9585)
		p.A_expr()
	}
	p.SetState(9588)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}
	_la = p.GetTokenStream().LA(1)

	if _la == PostgreSQLParserFOR {
		{
			p.SetState(9586)
			p.Match(PostgreSQLParserFOR)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(9587)
			p.A_expr()
		}

	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IPosition_listContext is an interface to support dynamic dispatch.
type IPosition_listContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	AllB_expr() []IB_exprContext
	B_expr(i int) IB_exprContext
	IN_P() antlr.TerminalNode

	// IsPosition_listContext differentiates from other interfaces.
	IsPosition_listContext()
}

type Position_listContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyPosition_listContext() *Position_listContext {
	var p = new(Position_listContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_position_list
	return p
}

func InitEmptyPosition_listContext(p *Position_listContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_position_list
}

func (*Position_listContext) IsPosition_listContext() {}

func NewPosition_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Position_listContext {
	var p = new(Position_listContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_position_list

	return p
}

func (s *Position_listContext) GetParser() antlr.Parser { return s.parser }

func (s *Position_listContext) AllB_expr() []IB_exprContext {
	children := s.GetChildren()
	len := 0
	for _, ctx := range children {
		if _, ok := ctx.(IB_exprContext); ok {
			len++
		}
	}

	tst := make([]IB_exprContext, len)
	i := 0
	for _, ctx := range children {
		if t, ok := ctx.(IB_exprContext); ok {
			tst[i] = t.(IB_exprContext)
			i++
		}
	}

	return tst
}

func (s *Position_listContext) B_expr(i int) IB_exprContext {
	var t antlr.RuleContext
	j := 0
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IB_exprContext); ok {
			if j == i {
				t = ctx.(antlr.RuleContext)
				break
			}
			j++
		}
	}

	if t == nil {
		return nil
	}

	return t.(IB_exprContext)
}

func (s *Position_listContext) IN_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserIN_P, 0)
}

func (s *Position_listContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Position_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Position_listContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterPosition_list(s)
	}
}

func (s *Position_listContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitPosition_list(s)
	}
}

func (s *Position_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitPosition_list(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Position_list() (localctx IPosition_listContext) {
	localctx = NewPosition_listContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1300, PostgreSQLParserRULE_position_list)
	p.SetState(9595)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetTokenStream().LA(1) {
	case PostgreSQLParserOPEN_PAREN, PostgreSQLParserPLUS, PostgreSQLParserMINUS, PostgreSQLParserPARAM, PostgreSQLParserOperator, PostgreSQLParserAND, PostgreSQLParserARRAY, PostgreSQLParserCASE, PostgreSQLParserCAST, PostgreSQLParserCOLLATE, PostgreSQLParserCOLUMN, PostgreSQLParserCONSTRAINT, PostgreSQLParserCURRENT_CATALOG, PostgreSQLParserCURRENT_DATE, PostgreSQLParserCURRENT_ROLE, PostgreSQLParserCURRENT_TIME, PostgreSQLParserCURRENT_TIMESTAMP, PostgreSQLParserCURRENT_USER, PostgreSQLParserDEFAULT, PostgreSQLParserDO, PostgreSQLParserFALSE_P, PostgreSQLParserFETCH, PostgreSQLParserLOCALTIME, PostgreSQLParserLOCALTIMESTAMP, PostgreSQLParserNULL_P, PostgreSQLParserSESSION_USER, PostgreSQLParserTABLE, PostgreSQLParserTRUE_P, PostgreSQLParserUNIQUE, PostgreSQLParserUSER, PostgreSQLParserAUTHORIZATION, PostgreSQLParserBINARY, PostgreSQLParserCOLLATION, PostgreSQLParserCONCURRENTLY, PostgreSQLParserCROSS, PostgreSQLParserCURRENT_SCHEMA, PostgreSQLParserFREEZE, PostgreSQLParserFULL, PostgreSQLParserILIKE, PostgreSQLParserINNER_P, PostgreSQLParserIS, PostgreSQLParserISNULL, PostgreSQLParserJOIN, PostgreSQLParserLEFT, PostgreSQLParserLIKE, PostgreSQLParserNATURAL, PostgreSQLParserNOTNULL, PostgreSQLParserOUTER_P, PostgreSQLParserOVER, PostgreSQLParserOVERLAPS, PostgreSQLParserRIGHT, PostgreSQLParserSIMILAR, PostgreSQLParserVERBOSE, PostgreSQLParserABORT_P, PostgreSQLParserABSOLUTE_P, PostgreSQLParserACCESS, PostgreSQLParserACTION, PostgreSQLParserADD_P, PostgreSQLParserADMIN, PostgreSQLParserAFTER, PostgreSQLParserAGGREGATE, PostgreSQLParserALSO, PostgreSQLParserALTER, PostgreSQLParserALWAYS, PostgreSQLParserASSERTION, PostgreSQLParserASSIGNMENT, PostgreSQLParserAT, PostgreSQLParserATTRIBUTE, PostgreSQLParserBACKWARD, PostgreSQLParserBEFORE, PostgreSQLParserBEGIN_P, PostgreSQLParserBY, PostgreSQLParserCACHE, PostgreSQLParserCALLED, PostgreSQLParserCASCADE, PostgreSQLParserCASCADED, PostgreSQLParserCATALOG, PostgreSQLParserCHAIN, PostgreSQLParserCHARACTERISTICS, PostgreSQLParserCHECKPOINT, PostgreSQLParserCLASS, PostgreSQLParserCLOSE, PostgreSQLParserCLUSTER, PostgreSQLParserCOMMENT, PostgreSQLParserCOMMENTS, PostgreSQLParserCOMMIT, PostgreSQLParserCOMMITTED, PostgreSQLParserCONFIGURATION, PostgreSQLParserCONNECTION, PostgreSQLParserCONSTRAINTS, PostgreSQLParserCONTENT_P, PostgreSQLParserCONTINUE_P, PostgreSQLParserCONVERSION_P, PostgreSQLParserCOPY, PostgreSQLParserCOST, PostgreSQLParserCSV, PostgreSQLParserCURSOR, PostgreSQLParserCYCLE, PostgreSQLParserDATA_P, PostgreSQLParserDATABASE, PostgreSQLParserDAY_P, PostgreSQLParserDEALLOCATE, PostgreSQLParserDECLARE, PostgreSQLParserDEFAULTS, PostgreSQLParserDEFERRED, PostgreSQLParserDEFINER, PostgreSQLParserDELETE_P, PostgreSQLParserDELIMITER, PostgreSQLParserDELIMITERS, PostgreSQLParserDICTIONARY, PostgreSQLParserDISABLE_P, PostgreSQLParserDISCARD, PostgreSQLParserDOCUMENT_P, PostgreSQLParserDOMAIN_P, PostgreSQLParserDOUBLE_P, PostgreSQLParserDROP, PostgreSQLParserEACH, PostgreSQLParserENABLE_P, PostgreSQLParserENCODING, PostgreSQLParserENCRYPTED, PostgreSQLParserENUM_P, PostgreSQLParserESCAPE, PostgreSQLParserEVENT, PostgreSQLParserEXCLUDE, PostgreSQLParserEXCLUDING, PostgreSQLParserEXCLUSIVE, PostgreSQLParserEXECUTE, PostgreSQLParserEXPLAIN, PostgreSQLParserEXTENSION, PostgreSQLParserEXTERNAL, PostgreSQLParserFAMILY, PostgreSQLParserFIRST_P, PostgreSQLParserFOLLOWING, PostgreSQLParserFORCE, PostgreSQLParserFORWARD, PostgreSQLParserFUNCTION, PostgreSQLParserFUNCTIONS, PostgreSQLParserGLOBAL, PostgreSQLParserGRANTED, PostgreSQLParserHANDLER, PostgreSQLParserHEADER_P, PostgreSQLParserHOLD, PostgreSQLParserHOUR_P, PostgreSQLParserIDENTITY_P, PostgreSQLParserIF_P, PostgreSQLParserIMMEDIATE, PostgreSQLParserIMMUTABLE, PostgreSQLParserIMPLICIT_P, PostgreSQLParserINCLUDING, PostgreSQLParserINCREMENT, PostgreSQLParserINDEX, PostgreSQLParserINDEXES, PostgreSQLParserINHERIT, PostgreSQLParserINHERITS, PostgreSQLParserINLINE_P, PostgreSQLParserINSENSITIVE, PostgreSQLParserINSERT, PostgreSQLParserINSTEAD, PostgreSQLParserINVOKER, PostgreSQLParserISOLATION, PostgreSQLParserKEY, PostgreSQLParserLABEL, PostgreSQLParserLANGUAGE, PostgreSQLParserLARGE_P, PostgreSQLParserLAST_P, PostgreSQLParserLEAKPROOF, PostgreSQLParserLEVEL, PostgreSQLParserLISTEN, PostgreSQLParserLOAD, PostgreSQLParserLOCAL, PostgreSQLParserLOCATION, PostgreSQLParserLOCK_P, PostgreSQLParserMAPPING, PostgreSQLParserMATCH, PostgreSQLParserMATERIALIZED, PostgreSQLParserMAXVALUE, PostgreSQLParserMINUTE_P, PostgreSQLParserMINVALUE, PostgreSQLParserMODE, PostgreSQLParserMONTH_P, PostgreSQLParserMOVE, PostgreSQLParserNAME_P, PostgreSQLParserNAMES, PostgreSQLParserNEXT, PostgreSQLParserNO, PostgreSQLParserNOTHING, PostgreSQLParserNOTIFY, PostgreSQLParserNOWAIT, PostgreSQLParserNULLS_P, PostgreSQLParserOBJECT_P, PostgreSQLParserOF, PostgreSQLParserOFF, PostgreSQLParserOIDS, PostgreSQLParserOPERATOR, PostgreSQLParserOPTION, PostgreSQLParserOPTIONS, PostgreSQLParserOWNED, PostgreSQLParserOWNER, PostgreSQLParserPARSER, PostgreSQLParserPARTIAL, PostgreSQLParserPARTITION, PostgreSQLParserPASSING, PostgreSQLParserPASSWORD, PostgreSQLParserPLANS, PostgreSQLParserPRECEDING, PostgreSQLParserPREPARE, PostgreSQLParserPREPARED, PostgreSQLParserPRESERVE, PostgreSQLParserPRIOR, PostgreSQLParserPRIVILEGES, PostgreSQLParserPROCEDURAL, PostgreSQLParserPROCEDURE, PostgreSQLParserPROGRAM, PostgreSQLParserQUOTE, PostgreSQLParserRANGE, PostgreSQLParserREAD, PostgreSQLParserREASSIGN, PostgreSQLParserRECHECK, PostgreSQLParserRECURSIVE, PostgreSQLParserREF, PostgreSQLParserREFRESH, PostgreSQLParserREINDEX, PostgreSQLParserRELATIVE_P, PostgreSQLParserRELEASE, PostgreSQLParserRENAME, PostgreSQLParserREPEATABLE, PostgreSQLParserREPLACE, PostgreSQLParserREPLICA, PostgreSQLParserRESET, PostgreSQLParserRESTART, PostgreSQLParserRESTRICT, PostgreSQLParserRETURNS, PostgreSQLParserREVOKE, PostgreSQLParserROLE, PostgreSQLParserROLLBACK, PostgreSQLParserROWS, PostgreSQLParserRULE, PostgreSQLParserSAVEPOINT, PostgreSQLParserSCHEMA, PostgreSQLParserSCROLL, PostgreSQLParserSEARCH, PostgreSQLParserSECOND_P, PostgreSQLParserSECURITY, PostgreSQLParserSEQUENCE, PostgreSQLParserSEQUENCES, PostgreSQLParserSERIALIZABLE, PostgreSQLParserSERVER, PostgreSQLParserSESSION, PostgreSQLParserSET, PostgreSQLParserSHARE, PostgreSQLParserSHOW, PostgreSQLParserSIMPLE, PostgreSQLParserSNAPSHOT, PostgreSQLParserSTABLE, PostgreSQLParserSTANDALONE_P, PostgreSQLParserSTART, PostgreSQLParserSTATEMENT, PostgreSQLParserSTATISTICS, PostgreSQLParserSTDIN, PostgreSQLParserSTDOUT, PostgreSQLParserSTORAGE, PostgreSQLParserSTRICT_P, PostgreSQLParserSTRIP_P, PostgreSQLParserSYSID, PostgreSQLParserSYSTEM_P, PostgreSQLParserTABLES, PostgreSQLParserTABLESPACE, PostgreSQLParserTEMP, PostgreSQLParserTEMPLATE, PostgreSQLParserTEMPORARY, PostgreSQLParserTEXT_P, PostgreSQLParserTRANSACTION, PostgreSQLParserTRIGGER, PostgreSQLParserTRUNCATE, PostgreSQLParserTRUSTED, PostgreSQLParserTYPE_P, PostgreSQLParserTYPES_P, PostgreSQLParserUNBOUNDED, PostgreSQLParserUNCOMMITTED, PostgreSQLParserUNENCRYPTED, PostgreSQLParserUNKNOWN, PostgreSQLParserUNLISTEN, PostgreSQLParserUNLOGGED, PostgreSQLParserUNTIL, PostgreSQLParserUPDATE, PostgreSQLParserVACUUM, PostgreSQLParserVALID, PostgreSQLParserVALIDATE, PostgreSQLParserVALIDATOR, PostgreSQLParserVARYING, PostgreSQLParserVERSION_P, PostgreSQLParserVIEW, PostgreSQLParserVOLATILE, PostgreSQLParserWHITESPACE_P, PostgreSQLParserWITHOUT, PostgreSQLParserWORK, PostgreSQLParserWRAPPER, PostgreSQLParserWRITE, PostgreSQLParserXML_P, PostgreSQLParserYEAR_P, PostgreSQLParserYES_P, PostgreSQLParserZONE, PostgreSQLParserBETWEEN, PostgreSQLParserBIGINT, PostgreSQLParserBIT, PostgreSQLParserBOOLEAN_P, PostgreSQLParserCHAR_P, PostgreSQLParserCHARACTER, PostgreSQLParserCOALESCE, PostgreSQLParserDEC, PostgreSQLParserDECIMAL_P, PostgreSQLParserEXISTS, PostgreSQLParserEXTRACT, PostgreSQLParserFLOAT_P, PostgreSQLParserGREATEST, PostgreSQLParserINOUT, PostgreSQLParserINT_P, PostgreSQLParserINTEGER, PostgreSQLParserINTERVAL, PostgreSQLParserLEAST, PostgreSQLParserNATIONAL, PostgreSQLParserNCHAR, PostgreSQLParserNONE, PostgreSQLParserNULLIF, PostgreSQLParserNUMERIC, PostgreSQLParserOVERLAY, PostgreSQLParserPOSITION, PostgreSQLParserPRECISION, PostgreSQLParserREAL, PostgreSQLParserROW, PostgreSQLParserSETOF, PostgreSQLParserSMALLINT, PostgreSQLParserSUBSTRING, PostgreSQLParserTIME, PostgreSQLParserTIMESTAMP, PostgreSQLParserTREAT, PostgreSQLParserTRIM, PostgreSQLParserVALUES, PostgreSQLParserVARCHAR, PostgreSQLParserXMLATTRIBUTES, PostgreSQLParserXMLCOMMENT, PostgreSQLParserXMLAGG, PostgreSQLParserXML_IS_WELL_FORMED, PostgreSQLParserXML_IS_WELL_FORMED_DOCUMENT, PostgreSQLParserXML_IS_WELL_FORMED_CONTENT, PostgreSQLParserXPATH, PostgreSQLParserXPATH_EXISTS, PostgreSQLParserXMLCONCAT, PostgreSQLParserXMLELEMENT, PostgreSQLParserXMLEXISTS, PostgreSQLParserXMLFOREST, PostgreSQLParserXMLPARSE, PostgreSQLParserXMLPI, PostgreSQLParserXMLROOT, PostgreSQLParserXMLSERIALIZE, PostgreSQLParserCALL, PostgreSQLParserCURRENT_P, PostgreSQLParserATTACH, PostgreSQLParserDETACH, PostgreSQLParserEXPRESSION, PostgreSQLParserGENERATED, PostgreSQLParserLOGGED, PostgreSQLParserSTORED, PostgreSQLParserINCLUDE, PostgreSQLParserROUTINE, PostgreSQLParserTRANSFORM, PostgreSQLParserIMPORT_P, PostgreSQLParserPOLICY, PostgreSQLParserMETHOD, PostgreSQLParserREFERENCING, PostgreSQLParserNEW, PostgreSQLParserOLD, PostgreSQLParserVALUE_P, PostgreSQLParserSUBSCRIPTION, PostgreSQLParserPUBLICATION, PostgreSQLParserOUT_P, PostgreSQLParserROUTINES, PostgreSQLParserSCHEMAS, PostgreSQLParserPROCEDURES, PostgreSQLParserINPUT_P, PostgreSQLParserSUPPORT, PostgreSQLParserPARALLEL, PostgreSQLParserSQL_P, PostgreSQLParserDEPENDS, PostgreSQLParserOVERRIDING, PostgreSQLParserCONFLICT, PostgreSQLParserSKIP_P, PostgreSQLParserLOCKED, PostgreSQLParserTIES, PostgreSQLParserROLLUP, PostgreSQLParserCUBE, PostgreSQLParserGROUPING, PostgreSQLParserSETS, PostgreSQLParserTABLESAMPLE, PostgreSQLParserORDINALITY, PostgreSQLParserXMLTABLE, PostgreSQLParserCOLUMNS, PostgreSQLParserXMLNAMESPACES, PostgreSQLParserROWTYPE, PostgreSQLParserNORMALIZED, PostgreSQLParserWITHIN, PostgreSQLParserFILTER, PostgreSQLParserGROUPS, PostgreSQLParserOTHERS, PostgreSQLParserNFC, PostgreSQLParserNFD, PostgreSQLParserNFKC, PostgreSQLParserNFKD, PostgreSQLParserUESCAPE, PostgreSQLParserVIEWS, PostgreSQLParserNORMALIZE, PostgreSQLParserDUMP, PostgreSQLParserPRINT_STRICT_PARAMS, PostgreSQLParserVARIABLE_CONFLICT, PostgreSQLParserERROR, PostgreSQLParserUSE_VARIABLE, PostgreSQLParserUSE_COLUMN, PostgreSQLParserALIAS, PostgreSQLParserCONSTANT, PostgreSQLParserPERFORM, PostgreSQLParserGET, PostgreSQLParserDIAGNOSTICS, PostgreSQLParserSTACKED, PostgreSQLParserELSIF, PostgreSQLParserREVERSE, PostgreSQLParserSLICE, PostgreSQLParserEXIT, PostgreSQLParserRETURN, PostgreSQLParserQUERY, PostgreSQLParserRAISE, PostgreSQLParserSQLSTATE, PostgreSQLParserDEBUG, PostgreSQLParserLOG, PostgreSQLParserINFO, PostgreSQLParserNOTICE, PostgreSQLParserWARNING, PostgreSQLParserEXCEPTION, PostgreSQLParserASSERT, PostgreSQLParserOPEN, PostgreSQLParserABS, PostgreSQLParserCBRT, PostgreSQLParserCEIL, PostgreSQLParserCEILING, PostgreSQLParserDEGREES, PostgreSQLParserDIV, PostgreSQLParserEXP, PostgreSQLParserFACTORIAL, PostgreSQLParserFLOOR, PostgreSQLParserGCD, PostgreSQLParserLCM, PostgreSQLParserLN, PostgreSQLParserLOG10, PostgreSQLParserMIN_SCALE, PostgreSQLParserMOD, PostgreSQLParserPI, PostgreSQLParserPOWER, PostgreSQLParserRADIANS, PostgreSQLParserROUND, PostgreSQLParserSCALE, PostgreSQLParserSIGN, PostgreSQLParserSQRT, PostgreSQLParserTRIM_SCALE, PostgreSQLParserTRUNC, PostgreSQLParserWIDTH_BUCKET, PostgreSQLParserRANDOM, PostgreSQLParserSETSEED, PostgreSQLParserACOS, PostgreSQLParserACOSD, PostgreSQLParserASIN, PostgreSQLParserASIND, PostgreSQLParserATAN, PostgreSQLParserATAND, PostgreSQLParserATAN2, PostgreSQLParserATAN2D, PostgreSQLParserCOS, PostgreSQLParserCOSD, PostgreSQLParserCOT, PostgreSQLParserCOTD, PostgreSQLParserSIN, PostgreSQLParserSIND, PostgreSQLParserTAN, PostgreSQLParserTAND, PostgreSQLParserSINH, PostgreSQLParserCOSH, PostgreSQLParserTANH, PostgreSQLParserASINH, PostgreSQLParserACOSH, PostgreSQLParserATANH, PostgreSQLParserBIT_LENGTH, PostgreSQLParserCHAR_LENGTH, PostgreSQLParserCHARACTER_LENGTH, PostgreSQLParserLOWER, PostgreSQLParserOCTET_LENGTH, PostgreSQLParserUPPER, PostgreSQLParserASCII, PostgreSQLParserBTRIM, PostgreSQLParserCHR, PostgreSQLParserCONCAT, PostgreSQLParserCONCAT_WS, PostgreSQLParserFORMAT, PostgreSQLParserINITCAP, PostgreSQLParserLENGTH, PostgreSQLParserLPAD, PostgreSQLParserLTRIM, PostgreSQLParserMD5, PostgreSQLParserPARSE_IDENT, PostgreSQLParserPG_CLIENT_ENCODING, PostgreSQLParserQUOTE_IDENT, PostgreSQLParserQUOTE_LITERAL, PostgreSQLParserQUOTE_NULLABLE, PostgreSQLParserREGEXP_COUNT, PostgreSQLParserREGEXP_INSTR, PostgreSQLParserREGEXP_LIKE, PostgreSQLParserREGEXP_MATCH, PostgreSQLParserREGEXP_MATCHES, PostgreSQLParserREGEXP_REPLACE, PostgreSQLParserREGEXP_SPLIT_TO_ARRAY, PostgreSQLParserREGEXP_SPLIT_TO_TABLE, PostgreSQLParserREGEXP_SUBSTR, PostgreSQLParserREPEAT, PostgreSQLParserRPAD, PostgreSQLParserRTRIM, PostgreSQLParserSPLIT_PART, PostgreSQLParserSTARTS_WITH, PostgreSQLParserSTRING_TO_ARRAY, PostgreSQLParserSTRING_TO_TABLE, PostgreSQLParserSTRPOS, PostgreSQLParserSUBSTR, PostgreSQLParserTO_ASCII, PostgreSQLParserTO_HEX, PostgreSQLParserTRANSLATE, PostgreSQLParserUNISTR, PostgreSQLParserAGE, PostgreSQLParserCLOCK_TIMESTAMP, PostgreSQLParserDATE_BIN, PostgreSQLParserDATE_PART, PostgreSQLParserDATE_TRUNC, PostgreSQLParserISFINITE, PostgreSQLParserJUSTIFY_DAYS, PostgreSQLParserJUSTIFY_HOURS, PostgreSQLParserJUSTIFY_INTERVAL, PostgreSQLParserMAKE_DATE, PostgreSQLParserMAKE_INTERVAL, PostgreSQLParserMAKE_TIME, PostgreSQLParserMAKE_TIMESTAMP, PostgreSQLParserMAKE_TIMESTAMPTZ, PostgreSQLParserNOW, PostgreSQLParserSTATEMENT_TIMESTAMP, PostgreSQLParserTIMEOFDAY, PostgreSQLParserTRANSACTION_TIMESTAMP, PostgreSQLParserTO_TIMESTAMP, PostgreSQLParserTO_CHAR, PostgreSQLParserTO_DATE, PostgreSQLParserTO_NUMBER, PostgreSQLParserIdentifier, PostgreSQLParserQuotedIdentifier, PostgreSQLParserUnicodeQuotedIdentifier, PostgreSQLParserStringConstant, PostgreSQLParserUnicodeEscapeStringConstant, PostgreSQLParserBeginDollarStringConstant, PostgreSQLParserBinaryStringConstant, PostgreSQLParserHexadecimalStringConstant, PostgreSQLParserIntegral, PostgreSQLParserNumeric, PostgreSQLParserPLSQLVARIABLENAME, PostgreSQLParserPLSQLIDENTIFIER, PostgreSQLParserEscapeStringConstant:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(9590)
			p.b_expr(0)
		}
		{
			p.SetState(9591)
			p.Match(PostgreSQLParserIN_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(9592)
			p.b_expr(0)
		}

	case PostgreSQLParserCLOSE_PAREN:
		p.EnterOuterAlt(localctx, 2)

	default:
		p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// ISubstr_listContext is an interface to support dynamic dispatch.
type ISubstr_listContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	AllA_expr() []IA_exprContext
	A_expr(i int) IA_exprContext
	FROM() antlr.TerminalNode
	FOR() antlr.TerminalNode
	SIMILAR() antlr.TerminalNode
	ESCAPE() antlr.TerminalNode
	Expr_list() IExpr_listContext

	// IsSubstr_listContext differentiates from other interfaces.
	IsSubstr_listContext()
}

type Substr_listContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptySubstr_listContext() *Substr_listContext {
	var p = new(Substr_listContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_substr_list
	return p
}

func InitEmptySubstr_listContext(p *Substr_listContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_substr_list
}

func (*Substr_listContext) IsSubstr_listContext() {}

func NewSubstr_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Substr_listContext {
	var p = new(Substr_listContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_substr_list

	return p
}

func (s *Substr_listContext) GetParser() antlr.Parser { return s.parser }

func (s *Substr_listContext) AllA_expr() []IA_exprContext {
	children := s.GetChildren()
	len := 0
	for _, ctx := range children {
		if _, ok := ctx.(IA_exprContext); ok {
			len++
		}
	}

	tst := make([]IA_exprContext, len)
	i := 0
	for _, ctx := range children {
		if t, ok := ctx.(IA_exprContext); ok {
			tst[i] = t.(IA_exprContext)
			i++
		}
	}

	return tst
}

func (s *Substr_listContext) A_expr(i int) IA_exprContext {
	var t antlr.RuleContext
	j := 0
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IA_exprContext); ok {
			if j == i {
				t = ctx.(antlr.RuleContext)
				break
			}
			j++
		}
	}

	if t == nil {
		return nil
	}

	return t.(IA_exprContext)
}

func (s *Substr_listContext) FROM() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserFROM, 0)
}

func (s *Substr_listContext) FOR() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserFOR, 0)
}

func (s *Substr_listContext) SIMILAR() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserSIMILAR, 0)
}

func (s *Substr_listContext) ESCAPE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserESCAPE, 0)
}

func (s *Substr_listContext) Expr_list() IExpr_listContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IExpr_listContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IExpr_listContext)
}

func (s *Substr_listContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Substr_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Substr_listContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterSubstr_list(s)
	}
}

func (s *Substr_listContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitSubstr_list(s)
	}
}

func (s *Substr_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitSubstr_list(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Substr_list() (localctx ISubstr_listContext) {
	localctx = NewSubstr_listContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1302, PostgreSQLParserRULE_substr_list)
	p.SetState(9624)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 628, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(9597)
			p.A_expr()
		}
		{
			p.SetState(9598)
			p.Match(PostgreSQLParserFROM)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(9599)
			p.A_expr()
		}
		{
			p.SetState(9600)
			p.Match(PostgreSQLParserFOR)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(9601)
			p.A_expr()
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(9603)
			p.A_expr()
		}
		{
			p.SetState(9604)
			p.Match(PostgreSQLParserFOR)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(9605)
			p.A_expr()
		}
		{
			p.SetState(9606)
			p.Match(PostgreSQLParserFROM)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(9607)
			p.A_expr()
		}

	case 3:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(9609)
			p.A_expr()
		}
		{
			p.SetState(9610)
			p.Match(PostgreSQLParserFROM)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(9611)
			p.A_expr()
		}

	case 4:
		p.EnterOuterAlt(localctx, 4)
		{
			p.SetState(9613)
			p.A_expr()
		}
		{
			p.SetState(9614)
			p.Match(PostgreSQLParserFOR)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(9615)
			p.A_expr()
		}

	case 5:
		p.EnterOuterAlt(localctx, 5)
		{
			p.SetState(9617)
			p.A_expr()
		}
		{
			p.SetState(9618)
			p.Match(PostgreSQLParserSIMILAR)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(9619)
			p.A_expr()
		}
		{
			p.SetState(9620)
			p.Match(PostgreSQLParserESCAPE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(9621)
			p.A_expr()
		}

	case 6:
		p.EnterOuterAlt(localctx, 6)
		{
			p.SetState(9623)
			p.Expr_list()
		}

	case antlr.ATNInvalidAltNumber:
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// ITrim_listContext is an interface to support dynamic dispatch.
type ITrim_listContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	A_expr() IA_exprContext
	FROM() antlr.TerminalNode
	Expr_list() IExpr_listContext

	// IsTrim_listContext differentiates from other interfaces.
	IsTrim_listContext()
}

type Trim_listContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyTrim_listContext() *Trim_listContext {
	var p = new(Trim_listContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_trim_list
	return p
}

func InitEmptyTrim_listContext(p *Trim_listContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_trim_list
}

func (*Trim_listContext) IsTrim_listContext() {}

func NewTrim_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Trim_listContext {
	var p = new(Trim_listContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_trim_list

	return p
}

func (s *Trim_listContext) GetParser() antlr.Parser { return s.parser }

func (s *Trim_listContext) A_expr() IA_exprContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IA_exprContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IA_exprContext)
}

func (s *Trim_listContext) FROM() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserFROM, 0)
}

func (s *Trim_listContext) Expr_list() IExpr_listContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IExpr_listContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IExpr_listContext)
}

func (s *Trim_listContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Trim_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Trim_listContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterTrim_list(s)
	}
}

func (s *Trim_listContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitTrim_list(s)
	}
}

func (s *Trim_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitTrim_list(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Trim_list() (localctx ITrim_listContext) {
	localctx = NewTrim_listContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1304, PostgreSQLParserRULE_trim_list)
	p.SetState(9633)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 629, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(9626)
			p.A_expr()
		}
		{
			p.SetState(9627)
			p.Match(PostgreSQLParserFROM)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(9628)
			p.Expr_list()
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(9630)
			p.Match(PostgreSQLParserFROM)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(9631)
			p.Expr_list()
		}

	case 3:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(9632)
			p.Expr_list()
		}

	case antlr.ATNInvalidAltNumber:
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IIn_exprContext is an interface to support dynamic dispatch.
type IIn_exprContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser
	// IsIn_exprContext differentiates from other interfaces.
	IsIn_exprContext()
}

type In_exprContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyIn_exprContext() *In_exprContext {
	var p = new(In_exprContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_in_expr
	return p
}

func InitEmptyIn_exprContext(p *In_exprContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_in_expr
}

func (*In_exprContext) IsIn_exprContext() {}

func NewIn_exprContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *In_exprContext {
	var p = new(In_exprContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_in_expr

	return p
}

func (s *In_exprContext) GetParser() antlr.Parser { return s.parser }

func (s *In_exprContext) CopyAll(ctx *In_exprContext) {
	s.CopyFrom(&ctx.BaseParserRuleContext)
}

func (s *In_exprContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *In_exprContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

type In_expr_listContext struct {
	In_exprContext
}

func NewIn_expr_listContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *In_expr_listContext {
	var p = new(In_expr_listContext)

	InitEmptyIn_exprContext(&p.In_exprContext)
	p.parser = parser
	p.CopyAll(ctx.(*In_exprContext))

	return p
}

func (s *In_expr_listContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *In_expr_listContext) OPEN_PAREN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserOPEN_PAREN, 0)
}

func (s *In_expr_listContext) Expr_list() IExpr_listContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IExpr_listContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IExpr_listContext)
}

func (s *In_expr_listContext) CLOSE_PAREN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCLOSE_PAREN, 0)
}

func (s *In_expr_listContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterIn_expr_list(s)
	}
}

func (s *In_expr_listContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitIn_expr_list(s)
	}
}

func (s *In_expr_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitIn_expr_list(s)

	default:
		return t.VisitChildren(s)
	}
}

type In_expr_selectContext struct {
	In_exprContext
}

func NewIn_expr_selectContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *In_expr_selectContext {
	var p = new(In_expr_selectContext)

	InitEmptyIn_exprContext(&p.In_exprContext)
	p.parser = parser
	p.CopyAll(ctx.(*In_exprContext))

	return p
}

func (s *In_expr_selectContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *In_expr_selectContext) Select_with_parens() ISelect_with_parensContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ISelect_with_parensContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ISelect_with_parensContext)
}

func (s *In_expr_selectContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterIn_expr_select(s)
	}
}

func (s *In_expr_selectContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitIn_expr_select(s)
	}
}

func (s *In_expr_selectContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitIn_expr_select(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) In_expr() (localctx IIn_exprContext) {
	localctx = NewIn_exprContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1306, PostgreSQLParserRULE_in_expr)
	p.SetState(9640)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 630, p.GetParserRuleContext()) {
	case 1:
		localctx = NewIn_expr_selectContext(p, localctx)
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(9635)
			p.Select_with_parens()
		}

	case 2:
		localctx = NewIn_expr_listContext(p, localctx)
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(9636)
			p.Match(PostgreSQLParserOPEN_PAREN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(9637)
			p.Expr_list()
		}
		{
			p.SetState(9638)
			p.Match(PostgreSQLParserCLOSE_PAREN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case antlr.ATNInvalidAltNumber:
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// ICase_exprContext is an interface to support dynamic dispatch.
type ICase_exprContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	CASE() antlr.TerminalNode
	Case_arg() ICase_argContext
	When_clause_list() IWhen_clause_listContext
	Case_default() ICase_defaultContext
	END_P() antlr.TerminalNode

	// IsCase_exprContext differentiates from other interfaces.
	IsCase_exprContext()
}

type Case_exprContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyCase_exprContext() *Case_exprContext {
	var p = new(Case_exprContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_case_expr
	return p
}

func InitEmptyCase_exprContext(p *Case_exprContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_case_expr
}

func (*Case_exprContext) IsCase_exprContext() {}

func NewCase_exprContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Case_exprContext {
	var p = new(Case_exprContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_case_expr

	return p
}

func (s *Case_exprContext) GetParser() antlr.Parser { return s.parser }

func (s *Case_exprContext) CASE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCASE, 0)
}

func (s *Case_exprContext) Case_arg() ICase_argContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ICase_argContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ICase_argContext)
}

func (s *Case_exprContext) When_clause_list() IWhen_clause_listContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IWhen_clause_listContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IWhen_clause_listContext)
}

func (s *Case_exprContext) Case_default() ICase_defaultContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ICase_defaultContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ICase_defaultContext)
}

func (s *Case_exprContext) END_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserEND_P, 0)
}

func (s *Case_exprContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Case_exprContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Case_exprContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterCase_expr(s)
	}
}

func (s *Case_exprContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitCase_expr(s)
	}
}

func (s *Case_exprContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitCase_expr(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Case_expr() (localctx ICase_exprContext) {
	localctx = NewCase_exprContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1308, PostgreSQLParserRULE_case_expr)
	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(9642)
		p.Match(PostgreSQLParserCASE)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(9643)
		p.Case_arg()
	}
	{
		p.SetState(9644)
		p.When_clause_list()
	}
	{
		p.SetState(9645)
		p.Case_default()
	}
	{
		p.SetState(9646)
		p.Match(PostgreSQLParserEND_P)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IWhen_clause_listContext is an interface to support dynamic dispatch.
type IWhen_clause_listContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	AllWhen_clause() []IWhen_clauseContext
	When_clause(i int) IWhen_clauseContext

	// IsWhen_clause_listContext differentiates from other interfaces.
	IsWhen_clause_listContext()
}

type When_clause_listContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyWhen_clause_listContext() *When_clause_listContext {
	var p = new(When_clause_listContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_when_clause_list
	return p
}

func InitEmptyWhen_clause_listContext(p *When_clause_listContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_when_clause_list
}

func (*When_clause_listContext) IsWhen_clause_listContext() {}

func NewWhen_clause_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *When_clause_listContext {
	var p = new(When_clause_listContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_when_clause_list

	return p
}

func (s *When_clause_listContext) GetParser() antlr.Parser { return s.parser }

func (s *When_clause_listContext) AllWhen_clause() []IWhen_clauseContext {
	children := s.GetChildren()
	len := 0
	for _, ctx := range children {
		if _, ok := ctx.(IWhen_clauseContext); ok {
			len++
		}
	}

	tst := make([]IWhen_clauseContext, len)
	i := 0
	for _, ctx := range children {
		if t, ok := ctx.(IWhen_clauseContext); ok {
			tst[i] = t.(IWhen_clauseContext)
			i++
		}
	}

	return tst
}

func (s *When_clause_listContext) When_clause(i int) IWhen_clauseContext {
	var t antlr.RuleContext
	j := 0
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IWhen_clauseContext); ok {
			if j == i {
				t = ctx.(antlr.RuleContext)
				break
			}
			j++
		}
	}

	if t == nil {
		return nil
	}

	return t.(IWhen_clauseContext)
}

func (s *When_clause_listContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *When_clause_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *When_clause_listContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterWhen_clause_list(s)
	}
}

func (s *When_clause_listContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitWhen_clause_list(s)
	}
}

func (s *When_clause_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitWhen_clause_list(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) When_clause_list() (localctx IWhen_clause_listContext) {
	localctx = NewWhen_clause_listContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1310, PostgreSQLParserRULE_when_clause_list)
	var _la int

	p.EnterOuterAlt(localctx, 1)
	p.SetState(9649)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}
	_la = p.GetTokenStream().LA(1)

	for ok := true; ok; ok = _la == PostgreSQLParserWHEN {
		{
			p.SetState(9648)
			p.When_clause()
		}

		p.SetState(9651)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}
		_la = p.GetTokenStream().LA(1)
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IWhen_clauseContext is an interface to support dynamic dispatch.
type IWhen_clauseContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	WHEN() antlr.TerminalNode
	AllA_expr() []IA_exprContext
	A_expr(i int) IA_exprContext
	THEN() antlr.TerminalNode

	// IsWhen_clauseContext differentiates from other interfaces.
	IsWhen_clauseContext()
}

type When_clauseContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyWhen_clauseContext() *When_clauseContext {
	var p = new(When_clauseContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_when_clause
	return p
}

func InitEmptyWhen_clauseContext(p *When_clauseContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_when_clause
}

func (*When_clauseContext) IsWhen_clauseContext() {}

func NewWhen_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *When_clauseContext {
	var p = new(When_clauseContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_when_clause

	return p
}

func (s *When_clauseContext) GetParser() antlr.Parser { return s.parser }

func (s *When_clauseContext) WHEN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserWHEN, 0)
}

func (s *When_clauseContext) AllA_expr() []IA_exprContext {
	children := s.GetChildren()
	len := 0
	for _, ctx := range children {
		if _, ok := ctx.(IA_exprContext); ok {
			len++
		}
	}

	tst := make([]IA_exprContext, len)
	i := 0
	for _, ctx := range children {
		if t, ok := ctx.(IA_exprContext); ok {
			tst[i] = t.(IA_exprContext)
			i++
		}
	}

	return tst
}

func (s *When_clauseContext) A_expr(i int) IA_exprContext {
	var t antlr.RuleContext
	j := 0
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IA_exprContext); ok {
			if j == i {
				t = ctx.(antlr.RuleContext)
				break
			}
			j++
		}
	}

	if t == nil {
		return nil
	}

	return t.(IA_exprContext)
}

func (s *When_clauseContext) THEN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserTHEN, 0)
}

func (s *When_clauseContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *When_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *When_clauseContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterWhen_clause(s)
	}
}

func (s *When_clauseContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitWhen_clause(s)
	}
}

func (s *When_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitWhen_clause(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) When_clause() (localctx IWhen_clauseContext) {
	localctx = NewWhen_clauseContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1312, PostgreSQLParserRULE_when_clause)
	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(9653)
		p.Match(PostgreSQLParserWHEN)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(9654)
		p.A_expr()
	}
	{
		p.SetState(9655)
		p.Match(PostgreSQLParserTHEN)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(9656)
		p.A_expr()
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// ICase_defaultContext is an interface to support dynamic dispatch.
type ICase_defaultContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	ELSE() antlr.TerminalNode
	A_expr() IA_exprContext

	// IsCase_defaultContext differentiates from other interfaces.
	IsCase_defaultContext()
}

type Case_defaultContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyCase_defaultContext() *Case_defaultContext {
	var p = new(Case_defaultContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_case_default
	return p
}

func InitEmptyCase_defaultContext(p *Case_defaultContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_case_default
}

func (*Case_defaultContext) IsCase_defaultContext() {}

func NewCase_defaultContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Case_defaultContext {
	var p = new(Case_defaultContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_case_default

	return p
}

func (s *Case_defaultContext) GetParser() antlr.Parser { return s.parser }

func (s *Case_defaultContext) ELSE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserELSE, 0)
}

func (s *Case_defaultContext) A_expr() IA_exprContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IA_exprContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IA_exprContext)
}

func (s *Case_defaultContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Case_defaultContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Case_defaultContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterCase_default(s)
	}
}

func (s *Case_defaultContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitCase_default(s)
	}
}

func (s *Case_defaultContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitCase_default(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Case_default() (localctx ICase_defaultContext) {
	localctx = NewCase_defaultContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1314, PostgreSQLParserRULE_case_default)
	p.SetState(9661)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetTokenStream().LA(1) {
	case PostgreSQLParserELSE:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(9658)
			p.Match(PostgreSQLParserELSE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(9659)
			p.A_expr()
		}

	case PostgreSQLParserEND_P:
		p.EnterOuterAlt(localctx, 2)

	default:
		p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// ICase_argContext is an interface to support dynamic dispatch.
type ICase_argContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	A_expr() IA_exprContext

	// IsCase_argContext differentiates from other interfaces.
	IsCase_argContext()
}

type Case_argContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyCase_argContext() *Case_argContext {
	var p = new(Case_argContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_case_arg
	return p
}

func InitEmptyCase_argContext(p *Case_argContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_case_arg
}

func (*Case_argContext) IsCase_argContext() {}

func NewCase_argContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Case_argContext {
	var p = new(Case_argContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_case_arg

	return p
}

func (s *Case_argContext) GetParser() antlr.Parser { return s.parser }

func (s *Case_argContext) A_expr() IA_exprContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IA_exprContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IA_exprContext)
}

func (s *Case_argContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Case_argContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Case_argContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterCase_arg(s)
	}
}

func (s *Case_argContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitCase_arg(s)
	}
}

func (s *Case_argContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitCase_arg(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Case_arg() (localctx ICase_argContext) {
	localctx = NewCase_argContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1316, PostgreSQLParserRULE_case_arg)
	p.SetState(9665)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetTokenStream().LA(1) {
	case PostgreSQLParserOPEN_PAREN, PostgreSQLParserPLUS, PostgreSQLParserMINUS, PostgreSQLParserPARAM, PostgreSQLParserOperator, PostgreSQLParserAND, PostgreSQLParserARRAY, PostgreSQLParserCASE, PostgreSQLParserCAST, PostgreSQLParserCOLLATE, PostgreSQLParserCOLUMN, PostgreSQLParserCONSTRAINT, PostgreSQLParserCURRENT_CATALOG, PostgreSQLParserCURRENT_DATE, PostgreSQLParserCURRENT_ROLE, PostgreSQLParserCURRENT_TIME, PostgreSQLParserCURRENT_TIMESTAMP, PostgreSQLParserCURRENT_USER, PostgreSQLParserDEFAULT, PostgreSQLParserDO, PostgreSQLParserFALSE_P, PostgreSQLParserFETCH, PostgreSQLParserLOCALTIME, PostgreSQLParserLOCALTIMESTAMP, PostgreSQLParserNOT, PostgreSQLParserNULL_P, PostgreSQLParserSESSION_USER, PostgreSQLParserTABLE, PostgreSQLParserTRUE_P, PostgreSQLParserUNIQUE, PostgreSQLParserUSER, PostgreSQLParserAUTHORIZATION, PostgreSQLParserBINARY, PostgreSQLParserCOLLATION, PostgreSQLParserCONCURRENTLY, PostgreSQLParserCROSS, PostgreSQLParserCURRENT_SCHEMA, PostgreSQLParserFREEZE, PostgreSQLParserFULL, PostgreSQLParserILIKE, PostgreSQLParserINNER_P, PostgreSQLParserIS, PostgreSQLParserISNULL, PostgreSQLParserJOIN, PostgreSQLParserLEFT, PostgreSQLParserLIKE, PostgreSQLParserNATURAL, PostgreSQLParserNOTNULL, PostgreSQLParserOUTER_P, PostgreSQLParserOVER, PostgreSQLParserOVERLAPS, PostgreSQLParserRIGHT, PostgreSQLParserSIMILAR, PostgreSQLParserVERBOSE, PostgreSQLParserABORT_P, PostgreSQLParserABSOLUTE_P, PostgreSQLParserACCESS, PostgreSQLParserACTION, PostgreSQLParserADD_P, PostgreSQLParserADMIN, PostgreSQLParserAFTER, PostgreSQLParserAGGREGATE, PostgreSQLParserALSO, PostgreSQLParserALTER, PostgreSQLParserALWAYS, PostgreSQLParserASSERTION, PostgreSQLParserASSIGNMENT, PostgreSQLParserAT, PostgreSQLParserATTRIBUTE, PostgreSQLParserBACKWARD, PostgreSQLParserBEFORE, PostgreSQLParserBEGIN_P, PostgreSQLParserBY, PostgreSQLParserCACHE, PostgreSQLParserCALLED, PostgreSQLParserCASCADE, PostgreSQLParserCASCADED, PostgreSQLParserCATALOG, PostgreSQLParserCHAIN, PostgreSQLParserCHARACTERISTICS, PostgreSQLParserCHECKPOINT, PostgreSQLParserCLASS, PostgreSQLParserCLOSE, PostgreSQLParserCLUSTER, PostgreSQLParserCOMMENT, PostgreSQLParserCOMMENTS, PostgreSQLParserCOMMIT, PostgreSQLParserCOMMITTED, PostgreSQLParserCONFIGURATION, PostgreSQLParserCONNECTION, PostgreSQLParserCONSTRAINTS, PostgreSQLParserCONTENT_P, PostgreSQLParserCONTINUE_P, PostgreSQLParserCONVERSION_P, PostgreSQLParserCOPY, PostgreSQLParserCOST, PostgreSQLParserCSV, PostgreSQLParserCURSOR, PostgreSQLParserCYCLE, PostgreSQLParserDATA_P, PostgreSQLParserDATABASE, PostgreSQLParserDAY_P, PostgreSQLParserDEALLOCATE, PostgreSQLParserDECLARE, PostgreSQLParserDEFAULTS, PostgreSQLParserDEFERRED, PostgreSQLParserDEFINER, PostgreSQLParserDELETE_P, PostgreSQLParserDELIMITER, PostgreSQLParserDELIMITERS, PostgreSQLParserDICTIONARY, PostgreSQLParserDISABLE_P, PostgreSQLParserDISCARD, PostgreSQLParserDOCUMENT_P, PostgreSQLParserDOMAIN_P, PostgreSQLParserDOUBLE_P, PostgreSQLParserDROP, PostgreSQLParserEACH, PostgreSQLParserENABLE_P, PostgreSQLParserENCODING, PostgreSQLParserENCRYPTED, PostgreSQLParserENUM_P, PostgreSQLParserESCAPE, PostgreSQLParserEVENT, PostgreSQLParserEXCLUDE, PostgreSQLParserEXCLUDING, PostgreSQLParserEXCLUSIVE, PostgreSQLParserEXECUTE, PostgreSQLParserEXPLAIN, PostgreSQLParserEXTENSION, PostgreSQLParserEXTERNAL, PostgreSQLParserFAMILY, PostgreSQLParserFIRST_P, PostgreSQLParserFOLLOWING, PostgreSQLParserFORCE, PostgreSQLParserFORWARD, PostgreSQLParserFUNCTION, PostgreSQLParserFUNCTIONS, PostgreSQLParserGLOBAL, PostgreSQLParserGRANTED, PostgreSQLParserHANDLER, PostgreSQLParserHEADER_P, PostgreSQLParserHOLD, PostgreSQLParserHOUR_P, PostgreSQLParserIDENTITY_P, PostgreSQLParserIF_P, PostgreSQLParserIMMEDIATE, PostgreSQLParserIMMUTABLE, PostgreSQLParserIMPLICIT_P, PostgreSQLParserINCLUDING, PostgreSQLParserINCREMENT, PostgreSQLParserINDEX, PostgreSQLParserINDEXES, PostgreSQLParserINHERIT, PostgreSQLParserINHERITS, PostgreSQLParserINLINE_P, PostgreSQLParserINSENSITIVE, PostgreSQLParserINSERT, PostgreSQLParserINSTEAD, PostgreSQLParserINVOKER, PostgreSQLParserISOLATION, PostgreSQLParserKEY, PostgreSQLParserLABEL, PostgreSQLParserLANGUAGE, PostgreSQLParserLARGE_P, PostgreSQLParserLAST_P, PostgreSQLParserLEAKPROOF, PostgreSQLParserLEVEL, PostgreSQLParserLISTEN, PostgreSQLParserLOAD, PostgreSQLParserLOCAL, PostgreSQLParserLOCATION, PostgreSQLParserLOCK_P, PostgreSQLParserMAPPING, PostgreSQLParserMATCH, PostgreSQLParserMATERIALIZED, PostgreSQLParserMAXVALUE, PostgreSQLParserMINUTE_P, PostgreSQLParserMINVALUE, PostgreSQLParserMODE, PostgreSQLParserMONTH_P, PostgreSQLParserMOVE, PostgreSQLParserNAME_P, PostgreSQLParserNAMES, PostgreSQLParserNEXT, PostgreSQLParserNO, PostgreSQLParserNOTHING, PostgreSQLParserNOTIFY, PostgreSQLParserNOWAIT, PostgreSQLParserNULLS_P, PostgreSQLParserOBJECT_P, PostgreSQLParserOF, PostgreSQLParserOFF, PostgreSQLParserOIDS, PostgreSQLParserOPERATOR, PostgreSQLParserOPTION, PostgreSQLParserOPTIONS, PostgreSQLParserOWNED, PostgreSQLParserOWNER, PostgreSQLParserPARSER, PostgreSQLParserPARTIAL, PostgreSQLParserPARTITION, PostgreSQLParserPASSING, PostgreSQLParserPASSWORD, PostgreSQLParserPLANS, PostgreSQLParserPRECEDING, PostgreSQLParserPREPARE, PostgreSQLParserPREPARED, PostgreSQLParserPRESERVE, PostgreSQLParserPRIOR, PostgreSQLParserPRIVILEGES, PostgreSQLParserPROCEDURAL, PostgreSQLParserPROCEDURE, PostgreSQLParserPROGRAM, PostgreSQLParserQUOTE, PostgreSQLParserRANGE, PostgreSQLParserREAD, PostgreSQLParserREASSIGN, PostgreSQLParserRECHECK, PostgreSQLParserRECURSIVE, PostgreSQLParserREF, PostgreSQLParserREFRESH, PostgreSQLParserREINDEX, PostgreSQLParserRELATIVE_P, PostgreSQLParserRELEASE, PostgreSQLParserRENAME, PostgreSQLParserREPEATABLE, PostgreSQLParserREPLACE, PostgreSQLParserREPLICA, PostgreSQLParserRESET, PostgreSQLParserRESTART, PostgreSQLParserRESTRICT, PostgreSQLParserRETURNS, PostgreSQLParserREVOKE, PostgreSQLParserROLE, PostgreSQLParserROLLBACK, PostgreSQLParserROWS, PostgreSQLParserRULE, PostgreSQLParserSAVEPOINT, PostgreSQLParserSCHEMA, PostgreSQLParserSCROLL, PostgreSQLParserSEARCH, PostgreSQLParserSECOND_P, PostgreSQLParserSECURITY, PostgreSQLParserSEQUENCE, PostgreSQLParserSEQUENCES, PostgreSQLParserSERIALIZABLE, PostgreSQLParserSERVER, PostgreSQLParserSESSION, PostgreSQLParserSET, PostgreSQLParserSHARE, PostgreSQLParserSHOW, PostgreSQLParserSIMPLE, PostgreSQLParserSNAPSHOT, PostgreSQLParserSTABLE, PostgreSQLParserSTANDALONE_P, PostgreSQLParserSTART, PostgreSQLParserSTATEMENT, PostgreSQLParserSTATISTICS, PostgreSQLParserSTDIN, PostgreSQLParserSTDOUT, PostgreSQLParserSTORAGE, PostgreSQLParserSTRICT_P, PostgreSQLParserSTRIP_P, PostgreSQLParserSYSID, PostgreSQLParserSYSTEM_P, PostgreSQLParserTABLES, PostgreSQLParserTABLESPACE, PostgreSQLParserTEMP, PostgreSQLParserTEMPLATE, PostgreSQLParserTEMPORARY, PostgreSQLParserTEXT_P, PostgreSQLParserTRANSACTION, PostgreSQLParserTRIGGER, PostgreSQLParserTRUNCATE, PostgreSQLParserTRUSTED, PostgreSQLParserTYPE_P, PostgreSQLParserTYPES_P, PostgreSQLParserUNBOUNDED, PostgreSQLParserUNCOMMITTED, PostgreSQLParserUNENCRYPTED, PostgreSQLParserUNKNOWN, PostgreSQLParserUNLISTEN, PostgreSQLParserUNLOGGED, PostgreSQLParserUNTIL, PostgreSQLParserUPDATE, PostgreSQLParserVACUUM, PostgreSQLParserVALID, PostgreSQLParserVALIDATE, PostgreSQLParserVALIDATOR, PostgreSQLParserVARYING, PostgreSQLParserVERSION_P, PostgreSQLParserVIEW, PostgreSQLParserVOLATILE, PostgreSQLParserWHITESPACE_P, PostgreSQLParserWITHOUT, PostgreSQLParserWORK, PostgreSQLParserWRAPPER, PostgreSQLParserWRITE, PostgreSQLParserXML_P, PostgreSQLParserYEAR_P, PostgreSQLParserYES_P, PostgreSQLParserZONE, PostgreSQLParserBETWEEN, PostgreSQLParserBIGINT, PostgreSQLParserBIT, PostgreSQLParserBOOLEAN_P, PostgreSQLParserCHAR_P, PostgreSQLParserCHARACTER, PostgreSQLParserCOALESCE, PostgreSQLParserDEC, PostgreSQLParserDECIMAL_P, PostgreSQLParserEXISTS, PostgreSQLParserEXTRACT, PostgreSQLParserFLOAT_P, PostgreSQLParserGREATEST, PostgreSQLParserINOUT, PostgreSQLParserINT_P, PostgreSQLParserINTEGER, PostgreSQLParserINTERVAL, PostgreSQLParserLEAST, PostgreSQLParserNATIONAL, PostgreSQLParserNCHAR, PostgreSQLParserNONE, PostgreSQLParserNULLIF, PostgreSQLParserNUMERIC, PostgreSQLParserOVERLAY, PostgreSQLParserPOSITION, PostgreSQLParserPRECISION, PostgreSQLParserREAL, PostgreSQLParserROW, PostgreSQLParserSETOF, PostgreSQLParserSMALLINT, PostgreSQLParserSUBSTRING, PostgreSQLParserTIME, PostgreSQLParserTIMESTAMP, PostgreSQLParserTREAT, PostgreSQLParserTRIM, PostgreSQLParserVALUES, PostgreSQLParserVARCHAR, PostgreSQLParserXMLATTRIBUTES, PostgreSQLParserXMLCOMMENT, PostgreSQLParserXMLAGG, PostgreSQLParserXML_IS_WELL_FORMED, PostgreSQLParserXML_IS_WELL_FORMED_DOCUMENT, PostgreSQLParserXML_IS_WELL_FORMED_CONTENT, PostgreSQLParserXPATH, PostgreSQLParserXPATH_EXISTS, PostgreSQLParserXMLCONCAT, PostgreSQLParserXMLELEMENT, PostgreSQLParserXMLEXISTS, PostgreSQLParserXMLFOREST, PostgreSQLParserXMLPARSE, PostgreSQLParserXMLPI, PostgreSQLParserXMLROOT, PostgreSQLParserXMLSERIALIZE, PostgreSQLParserCALL, PostgreSQLParserCURRENT_P, PostgreSQLParserATTACH, PostgreSQLParserDETACH, PostgreSQLParserEXPRESSION, PostgreSQLParserGENERATED, PostgreSQLParserLOGGED, PostgreSQLParserSTORED, PostgreSQLParserINCLUDE, PostgreSQLParserROUTINE, PostgreSQLParserTRANSFORM, PostgreSQLParserIMPORT_P, PostgreSQLParserPOLICY, PostgreSQLParserMETHOD, PostgreSQLParserREFERENCING, PostgreSQLParserNEW, PostgreSQLParserOLD, PostgreSQLParserVALUE_P, PostgreSQLParserSUBSCRIPTION, PostgreSQLParserPUBLICATION, PostgreSQLParserOUT_P, PostgreSQLParserROUTINES, PostgreSQLParserSCHEMAS, PostgreSQLParserPROCEDURES, PostgreSQLParserINPUT_P, PostgreSQLParserSUPPORT, PostgreSQLParserPARALLEL, PostgreSQLParserSQL_P, PostgreSQLParserDEPENDS, PostgreSQLParserOVERRIDING, PostgreSQLParserCONFLICT, PostgreSQLParserSKIP_P, PostgreSQLParserLOCKED, PostgreSQLParserTIES, PostgreSQLParserROLLUP, PostgreSQLParserCUBE, PostgreSQLParserGROUPING, PostgreSQLParserSETS, PostgreSQLParserTABLESAMPLE, PostgreSQLParserORDINALITY, PostgreSQLParserXMLTABLE, PostgreSQLParserCOLUMNS, PostgreSQLParserXMLNAMESPACES, PostgreSQLParserROWTYPE, PostgreSQLParserNORMALIZED, PostgreSQLParserWITHIN, PostgreSQLParserFILTER, PostgreSQLParserGROUPS, PostgreSQLParserOTHERS, PostgreSQLParserNFC, PostgreSQLParserNFD, PostgreSQLParserNFKC, PostgreSQLParserNFKD, PostgreSQLParserUESCAPE, PostgreSQLParserVIEWS, PostgreSQLParserNORMALIZE, PostgreSQLParserDUMP, PostgreSQLParserPRINT_STRICT_PARAMS, PostgreSQLParserVARIABLE_CONFLICT, PostgreSQLParserERROR, PostgreSQLParserUSE_VARIABLE, PostgreSQLParserUSE_COLUMN, PostgreSQLParserALIAS, PostgreSQLParserCONSTANT, PostgreSQLParserPERFORM, PostgreSQLParserGET, PostgreSQLParserDIAGNOSTICS, PostgreSQLParserSTACKED, PostgreSQLParserELSIF, PostgreSQLParserREVERSE, PostgreSQLParserSLICE, PostgreSQLParserEXIT, PostgreSQLParserRETURN, PostgreSQLParserQUERY, PostgreSQLParserRAISE, PostgreSQLParserSQLSTATE, PostgreSQLParserDEBUG, PostgreSQLParserLOG, PostgreSQLParserINFO, PostgreSQLParserNOTICE, PostgreSQLParserWARNING, PostgreSQLParserEXCEPTION, PostgreSQLParserASSERT, PostgreSQLParserOPEN, PostgreSQLParserABS, PostgreSQLParserCBRT, PostgreSQLParserCEIL, PostgreSQLParserCEILING, PostgreSQLParserDEGREES, PostgreSQLParserDIV, PostgreSQLParserEXP, PostgreSQLParserFACTORIAL, PostgreSQLParserFLOOR, PostgreSQLParserGCD, PostgreSQLParserLCM, PostgreSQLParserLN, PostgreSQLParserLOG10, PostgreSQLParserMIN_SCALE, PostgreSQLParserMOD, PostgreSQLParserPI, PostgreSQLParserPOWER, PostgreSQLParserRADIANS, PostgreSQLParserROUND, PostgreSQLParserSCALE, PostgreSQLParserSIGN, PostgreSQLParserSQRT, PostgreSQLParserTRIM_SCALE, PostgreSQLParserTRUNC, PostgreSQLParserWIDTH_BUCKET, PostgreSQLParserRANDOM, PostgreSQLParserSETSEED, PostgreSQLParserACOS, PostgreSQLParserACOSD, PostgreSQLParserASIN, PostgreSQLParserASIND, PostgreSQLParserATAN, PostgreSQLParserATAND, PostgreSQLParserATAN2, PostgreSQLParserATAN2D, PostgreSQLParserCOS, PostgreSQLParserCOSD, PostgreSQLParserCOT, PostgreSQLParserCOTD, PostgreSQLParserSIN, PostgreSQLParserSIND, PostgreSQLParserTAN, PostgreSQLParserTAND, PostgreSQLParserSINH, PostgreSQLParserCOSH, PostgreSQLParserTANH, PostgreSQLParserASINH, PostgreSQLParserACOSH, PostgreSQLParserATANH, PostgreSQLParserBIT_LENGTH, PostgreSQLParserCHAR_LENGTH, PostgreSQLParserCHARACTER_LENGTH, PostgreSQLParserLOWER, PostgreSQLParserOCTET_LENGTH, PostgreSQLParserUPPER, PostgreSQLParserASCII, PostgreSQLParserBTRIM, PostgreSQLParserCHR, PostgreSQLParserCONCAT, PostgreSQLParserCONCAT_WS, PostgreSQLParserFORMAT, PostgreSQLParserINITCAP, PostgreSQLParserLENGTH, PostgreSQLParserLPAD, PostgreSQLParserLTRIM, PostgreSQLParserMD5, PostgreSQLParserPARSE_IDENT, PostgreSQLParserPG_CLIENT_ENCODING, PostgreSQLParserQUOTE_IDENT, PostgreSQLParserQUOTE_LITERAL, PostgreSQLParserQUOTE_NULLABLE, PostgreSQLParserREGEXP_COUNT, PostgreSQLParserREGEXP_INSTR, PostgreSQLParserREGEXP_LIKE, PostgreSQLParserREGEXP_MATCH, PostgreSQLParserREGEXP_MATCHES, PostgreSQLParserREGEXP_REPLACE, PostgreSQLParserREGEXP_SPLIT_TO_ARRAY, PostgreSQLParserREGEXP_SPLIT_TO_TABLE, PostgreSQLParserREGEXP_SUBSTR, PostgreSQLParserREPEAT, PostgreSQLParserRPAD, PostgreSQLParserRTRIM, PostgreSQLParserSPLIT_PART, PostgreSQLParserSTARTS_WITH, PostgreSQLParserSTRING_TO_ARRAY, PostgreSQLParserSTRING_TO_TABLE, PostgreSQLParserSTRPOS, PostgreSQLParserSUBSTR, PostgreSQLParserTO_ASCII, PostgreSQLParserTO_HEX, PostgreSQLParserTRANSLATE, PostgreSQLParserUNISTR, PostgreSQLParserAGE, PostgreSQLParserCLOCK_TIMESTAMP, PostgreSQLParserDATE_BIN, PostgreSQLParserDATE_PART, PostgreSQLParserDATE_TRUNC, PostgreSQLParserISFINITE, PostgreSQLParserJUSTIFY_DAYS, PostgreSQLParserJUSTIFY_HOURS, PostgreSQLParserJUSTIFY_INTERVAL, PostgreSQLParserMAKE_DATE, PostgreSQLParserMAKE_INTERVAL, PostgreSQLParserMAKE_TIME, PostgreSQLParserMAKE_TIMESTAMP, PostgreSQLParserMAKE_TIMESTAMPTZ, PostgreSQLParserNOW, PostgreSQLParserSTATEMENT_TIMESTAMP, PostgreSQLParserTIMEOFDAY, PostgreSQLParserTRANSACTION_TIMESTAMP, PostgreSQLParserTO_TIMESTAMP, PostgreSQLParserTO_CHAR, PostgreSQLParserTO_DATE, PostgreSQLParserTO_NUMBER, PostgreSQLParserIdentifier, PostgreSQLParserQuotedIdentifier, PostgreSQLParserUnicodeQuotedIdentifier, PostgreSQLParserStringConstant, PostgreSQLParserUnicodeEscapeStringConstant, PostgreSQLParserBeginDollarStringConstant, PostgreSQLParserBinaryStringConstant, PostgreSQLParserHexadecimalStringConstant, PostgreSQLParserIntegral, PostgreSQLParserNumeric, PostgreSQLParserPLSQLVARIABLENAME, PostgreSQLParserPLSQLIDENTIFIER, PostgreSQLParserEscapeStringConstant:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(9663)
			p.A_expr()
		}

	case PostgreSQLParserWHEN:
		p.EnterOuterAlt(localctx, 2)

	default:
		p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IColumnrefContext is an interface to support dynamic dispatch.
type IColumnrefContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Colid() IColidContext
	Indirection() IIndirectionContext

	// IsColumnrefContext differentiates from other interfaces.
	IsColumnrefContext()
}

type ColumnrefContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyColumnrefContext() *ColumnrefContext {
	var p = new(ColumnrefContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_columnref
	return p
}

func InitEmptyColumnrefContext(p *ColumnrefContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_columnref
}

func (*ColumnrefContext) IsColumnrefContext() {}

func NewColumnrefContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ColumnrefContext {
	var p = new(ColumnrefContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_columnref

	return p
}

func (s *ColumnrefContext) GetParser() antlr.Parser { return s.parser }

func (s *ColumnrefContext) Colid() IColidContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IColidContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IColidContext)
}

func (s *ColumnrefContext) Indirection() IIndirectionContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IIndirectionContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IIndirectionContext)
}

func (s *ColumnrefContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *ColumnrefContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *ColumnrefContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterColumnref(s)
	}
}

func (s *ColumnrefContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitColumnref(s)
	}
}

func (s *ColumnrefContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitColumnref(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Columnref() (localctx IColumnrefContext) {
	localctx = NewColumnrefContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1318, PostgreSQLParserRULE_columnref)
	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(9667)
		p.Colid()
	}
	p.SetState(9669)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 634, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(9668)
			p.Indirection()
		}

	} else if p.HasError() { // JIM
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IIndirection_elContext is an interface to support dynamic dispatch.
type IIndirection_elContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	DOT() antlr.TerminalNode
	Attr_name() IAttr_nameContext
	STAR() antlr.TerminalNode
	OPEN_BRACKET() antlr.TerminalNode
	CLOSE_BRACKET() antlr.TerminalNode
	A_expr() IA_exprContext
	AllOpt_slice_bound() []IOpt_slice_boundContext
	Opt_slice_bound(i int) IOpt_slice_boundContext
	COLON() antlr.TerminalNode

	// IsIndirection_elContext differentiates from other interfaces.
	IsIndirection_elContext()
}

type Indirection_elContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyIndirection_elContext() *Indirection_elContext {
	var p = new(Indirection_elContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_indirection_el
	return p
}

func InitEmptyIndirection_elContext(p *Indirection_elContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_indirection_el
}

func (*Indirection_elContext) IsIndirection_elContext() {}

func NewIndirection_elContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Indirection_elContext {
	var p = new(Indirection_elContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_indirection_el

	return p
}

func (s *Indirection_elContext) GetParser() antlr.Parser { return s.parser }

func (s *Indirection_elContext) DOT() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserDOT, 0)
}

func (s *Indirection_elContext) Attr_name() IAttr_nameContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IAttr_nameContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IAttr_nameContext)
}

func (s *Indirection_elContext) STAR() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserSTAR, 0)
}

func (s *Indirection_elContext) OPEN_BRACKET() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserOPEN_BRACKET, 0)
}

func (s *Indirection_elContext) CLOSE_BRACKET() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCLOSE_BRACKET, 0)
}

func (s *Indirection_elContext) A_expr() IA_exprContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IA_exprContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IA_exprContext)
}

func (s *Indirection_elContext) AllOpt_slice_bound() []IOpt_slice_boundContext {
	children := s.GetChildren()
	len := 0
	for _, ctx := range children {
		if _, ok := ctx.(IOpt_slice_boundContext); ok {
			len++
		}
	}

	tst := make([]IOpt_slice_boundContext, len)
	i := 0
	for _, ctx := range children {
		if t, ok := ctx.(IOpt_slice_boundContext); ok {
			tst[i] = t.(IOpt_slice_boundContext)
			i++
		}
	}

	return tst
}

func (s *Indirection_elContext) Opt_slice_bound(i int) IOpt_slice_boundContext {
	var t antlr.RuleContext
	j := 0
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOpt_slice_boundContext); ok {
			if j == i {
				t = ctx.(antlr.RuleContext)
				break
			}
			j++
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOpt_slice_boundContext)
}

func (s *Indirection_elContext) COLON() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCOLON, 0)
}

func (s *Indirection_elContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Indirection_elContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Indirection_elContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterIndirection_el(s)
	}
}

func (s *Indirection_elContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitIndirection_el(s)
	}
}

func (s *Indirection_elContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitIndirection_el(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Indirection_el() (localctx IIndirection_elContext) {
	localctx = NewIndirection_elContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1320, PostgreSQLParserRULE_indirection_el)
	p.SetState(9686)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetTokenStream().LA(1) {
	case PostgreSQLParserDOT:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(9671)
			p.Match(PostgreSQLParserDOT)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		p.SetState(9674)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}

		switch p.GetTokenStream().LA(1) {
		case PostgreSQLParserALL, PostgreSQLParserANALYSE, PostgreSQLParserANALYZE, PostgreSQLParserAND, PostgreSQLParserANY, PostgreSQLParserARRAY, PostgreSQLParserAS, PostgreSQLParserASC, PostgreSQLParserASYMMETRIC, PostgreSQLParserBOTH, PostgreSQLParserCASE, PostgreSQLParserCAST, PostgreSQLParserCHECK, PostgreSQLParserCOLLATE, PostgreSQLParserCOLUMN, PostgreSQLParserCONSTRAINT, PostgreSQLParserCREATE, PostgreSQLParserCURRENT_CATALOG, PostgreSQLParserCURRENT_DATE, PostgreSQLParserCURRENT_ROLE, PostgreSQLParserCURRENT_TIME, PostgreSQLParserCURRENT_TIMESTAMP, PostgreSQLParserCURRENT_USER, PostgreSQLParserDEFAULT, PostgreSQLParserDEFERRABLE, PostgreSQLParserDESC, PostgreSQLParserDISTINCT, PostgreSQLParserDO, PostgreSQLParserELSE, PostgreSQLParserEXCEPT, PostgreSQLParserFALSE_P, PostgreSQLParserFETCH, PostgreSQLParserFOR, PostgreSQLParserFOREIGN, PostgreSQLParserFROM, PostgreSQLParserGRANT, PostgreSQLParserGROUP_P, PostgreSQLParserHAVING, PostgreSQLParserIN_P, PostgreSQLParserINITIALLY, PostgreSQLParserINTERSECT, PostgreSQLParserLATERAL_P, PostgreSQLParserLEADING, PostgreSQLParserLIMIT, PostgreSQLParserLOCALTIME, PostgreSQLParserLOCALTIMESTAMP, PostgreSQLParserNOT, PostgreSQLParserNULL_P, PostgreSQLParserOFFSET, PostgreSQLParserON, PostgreSQLParserONLY, PostgreSQLParserOR, PostgreSQLParserORDER, PostgreSQLParserPLACING, PostgreSQLParserPRIMARY, PostgreSQLParserREFERENCES, PostgreSQLParserRETURNING, PostgreSQLParserSELECT, PostgreSQLParserSESSION_USER, PostgreSQLParserSOME, PostgreSQLParserSYMMETRIC, PostgreSQLParserTABLE, PostgreSQLParserTHEN, PostgreSQLParserTO, PostgreSQLParserTRAILING, PostgreSQLParserTRUE_P, PostgreSQLParserUNION, PostgreSQLParserUNIQUE, PostgreSQLParserUSER, PostgreSQLParserUSING, PostgreSQLParserVARIADIC, PostgreSQLParserWHEN, PostgreSQLParserWHERE, PostgreSQLParserWINDOW, PostgreSQLParserWITH, PostgreSQLParserAUTHORIZATION, PostgreSQLParserBINARY, PostgreSQLParserCOLLATION, PostgreSQLParserCONCURRENTLY, PostgreSQLParserCROSS, PostgreSQLParserCURRENT_SCHEMA, PostgreSQLParserFREEZE, PostgreSQLParserFULL, PostgreSQLParserILIKE, PostgreSQLParserINNER_P, PostgreSQLParserIS, PostgreSQLParserISNULL, PostgreSQLParserJOIN, PostgreSQLParserLIKE, PostgreSQLParserNATURAL, PostgreSQLParserNOTNULL, PostgreSQLParserOUTER_P, PostgreSQLParserOVER, PostgreSQLParserOVERLAPS, PostgreSQLParserSIMILAR, PostgreSQLParserVERBOSE, PostgreSQLParserABORT_P, PostgreSQLParserABSOLUTE_P, PostgreSQLParserACCESS, PostgreSQLParserACTION, PostgreSQLParserADD_P, PostgreSQLParserADMIN, PostgreSQLParserAFTER, PostgreSQLParserAGGREGATE, PostgreSQLParserALSO, PostgreSQLParserALTER, PostgreSQLParserALWAYS, PostgreSQLParserASSERTION, PostgreSQLParserASSIGNMENT, PostgreSQLParserAT, PostgreSQLParserATTRIBUTE, PostgreSQLParserBACKWARD, PostgreSQLParserBEFORE, PostgreSQLParserBEGIN_P, PostgreSQLParserBY, PostgreSQLParserCACHE, PostgreSQLParserCALLED, PostgreSQLParserCASCADE, PostgreSQLParserCASCADED, PostgreSQLParserCATALOG, PostgreSQLParserCHAIN, PostgreSQLParserCHARACTERISTICS, PostgreSQLParserCHECKPOINT, PostgreSQLParserCLASS, PostgreSQLParserCLOSE, PostgreSQLParserCLUSTER, PostgreSQLParserCOMMENT, PostgreSQLParserCOMMENTS, PostgreSQLParserCOMMIT, PostgreSQLParserCOMMITTED, PostgreSQLParserCONFIGURATION, PostgreSQLParserCONNECTION, PostgreSQLParserCONSTRAINTS, PostgreSQLParserCONTENT_P, PostgreSQLParserCONTINUE_P, PostgreSQLParserCONVERSION_P, PostgreSQLParserCOPY, PostgreSQLParserCOST, PostgreSQLParserCSV, PostgreSQLParserCURSOR, PostgreSQLParserCYCLE, PostgreSQLParserDATA_P, PostgreSQLParserDATABASE, PostgreSQLParserDAY_P, PostgreSQLParserDEALLOCATE, PostgreSQLParserDECLARE, PostgreSQLParserDEFAULTS, PostgreSQLParserDEFERRED, PostgreSQLParserDEFINER, PostgreSQLParserDELETE_P, PostgreSQLParserDELIMITER, PostgreSQLParserDELIMITERS, PostgreSQLParserDICTIONARY, PostgreSQLParserDISABLE_P, PostgreSQLParserDISCARD, PostgreSQLParserDOCUMENT_P, PostgreSQLParserDOMAIN_P, PostgreSQLParserDOUBLE_P, PostgreSQLParserDROP, PostgreSQLParserEACH, PostgreSQLParserENABLE_P, PostgreSQLParserENCODING, PostgreSQLParserENCRYPTED, PostgreSQLParserENUM_P, PostgreSQLParserESCAPE, PostgreSQLParserEVENT, PostgreSQLParserEXCLUDE, PostgreSQLParserEXCLUDING, PostgreSQLParserEXCLUSIVE, PostgreSQLParserEXECUTE, PostgreSQLParserEXPLAIN, PostgreSQLParserEXTENSION, PostgreSQLParserEXTERNAL, PostgreSQLParserFAMILY, PostgreSQLParserFIRST_P, PostgreSQLParserFOLLOWING, PostgreSQLParserFORCE, PostgreSQLParserFORWARD, PostgreSQLParserFUNCTION, PostgreSQLParserFUNCTIONS, PostgreSQLParserGLOBAL, PostgreSQLParserGRANTED, PostgreSQLParserHANDLER, PostgreSQLParserHEADER_P, PostgreSQLParserHOLD, PostgreSQLParserHOUR_P, PostgreSQLParserIDENTITY_P, PostgreSQLParserIF_P, PostgreSQLParserIMMEDIATE, PostgreSQLParserIMMUTABLE, PostgreSQLParserIMPLICIT_P, PostgreSQLParserINCLUDING, PostgreSQLParserINCREMENT, PostgreSQLParserINDEX, PostgreSQLParserINDEXES, PostgreSQLParserINHERIT, PostgreSQLParserINHERITS, PostgreSQLParserINLINE_P, PostgreSQLParserINSENSITIVE, PostgreSQLParserINSERT, PostgreSQLParserINSTEAD, PostgreSQLParserINVOKER, PostgreSQLParserISOLATION, PostgreSQLParserKEY, PostgreSQLParserLABEL, PostgreSQLParserLANGUAGE, PostgreSQLParserLARGE_P, PostgreSQLParserLAST_P, PostgreSQLParserLEAKPROOF, PostgreSQLParserLEVEL, PostgreSQLParserLISTEN, PostgreSQLParserLOAD, PostgreSQLParserLOCAL, PostgreSQLParserLOCATION, PostgreSQLParserLOCK_P, PostgreSQLParserMAPPING, PostgreSQLParserMATCH, PostgreSQLParserMATERIALIZED, PostgreSQLParserMAXVALUE, PostgreSQLParserMINUTE_P, PostgreSQLParserMINVALUE, PostgreSQLParserMODE, PostgreSQLParserMONTH_P, PostgreSQLParserMOVE, PostgreSQLParserNAME_P, PostgreSQLParserNAMES, PostgreSQLParserNEXT, PostgreSQLParserNO, PostgreSQLParserNOTHING, PostgreSQLParserNOTIFY, PostgreSQLParserNOWAIT, PostgreSQLParserNULLS_P, PostgreSQLParserOBJECT_P, PostgreSQLParserOF, PostgreSQLParserOFF, PostgreSQLParserOIDS, PostgreSQLParserOPERATOR, PostgreSQLParserOPTION, PostgreSQLParserOPTIONS, PostgreSQLParserOWNED, PostgreSQLParserOWNER, PostgreSQLParserPARSER, PostgreSQLParserPARTIAL, PostgreSQLParserPARTITION, PostgreSQLParserPASSING, PostgreSQLParserPASSWORD, PostgreSQLParserPLANS, PostgreSQLParserPRECEDING, PostgreSQLParserPREPARE, PostgreSQLParserPREPARED, PostgreSQLParserPRESERVE, PostgreSQLParserPRIOR, PostgreSQLParserPRIVILEGES, PostgreSQLParserPROCEDURAL, PostgreSQLParserPROCEDURE, PostgreSQLParserPROGRAM, PostgreSQLParserQUOTE, PostgreSQLParserRANGE, PostgreSQLParserREAD, PostgreSQLParserREASSIGN, PostgreSQLParserRECHECK, PostgreSQLParserRECURSIVE, PostgreSQLParserREF, PostgreSQLParserREFRESH, PostgreSQLParserREINDEX, PostgreSQLParserRELATIVE_P, PostgreSQLParserRELEASE, PostgreSQLParserRENAME, PostgreSQLParserREPEATABLE, PostgreSQLParserREPLACE, PostgreSQLParserREPLICA, PostgreSQLParserRESET, PostgreSQLParserRESTART, PostgreSQLParserRESTRICT, PostgreSQLParserRETURNS, PostgreSQLParserREVOKE, PostgreSQLParserROLE, PostgreSQLParserROLLBACK, PostgreSQLParserROWS, PostgreSQLParserRULE, PostgreSQLParserSAVEPOINT, PostgreSQLParserSCHEMA, PostgreSQLParserSCROLL, PostgreSQLParserSEARCH, PostgreSQLParserSECOND_P, PostgreSQLParserSECURITY, PostgreSQLParserSEQUENCE, PostgreSQLParserSEQUENCES, PostgreSQLParserSERIALIZABLE, PostgreSQLParserSERVER, PostgreSQLParserSESSION, PostgreSQLParserSET, PostgreSQLParserSHARE, PostgreSQLParserSHOW, PostgreSQLParserSIMPLE, PostgreSQLParserSNAPSHOT, PostgreSQLParserSTABLE, PostgreSQLParserSTANDALONE_P, PostgreSQLParserSTART, PostgreSQLParserSTATEMENT, PostgreSQLParserSTATISTICS, PostgreSQLParserSTDIN, PostgreSQLParserSTDOUT, PostgreSQLParserSTORAGE, PostgreSQLParserSTRICT_P, PostgreSQLParserSTRIP_P, PostgreSQLParserSYSID, PostgreSQLParserSYSTEM_P, PostgreSQLParserTABLES, PostgreSQLParserTABLESPACE, PostgreSQLParserTEMP, PostgreSQLParserTEMPLATE, PostgreSQLParserTEMPORARY, PostgreSQLParserTEXT_P, PostgreSQLParserTRANSACTION, PostgreSQLParserTRIGGER, PostgreSQLParserTRUNCATE, PostgreSQLParserTRUSTED, PostgreSQLParserTYPE_P, PostgreSQLParserTYPES_P, PostgreSQLParserUNBOUNDED, PostgreSQLParserUNCOMMITTED, PostgreSQLParserUNENCRYPTED, PostgreSQLParserUNKNOWN, PostgreSQLParserUNLISTEN, PostgreSQLParserUNLOGGED, PostgreSQLParserUNTIL, PostgreSQLParserUPDATE, PostgreSQLParserVACUUM, PostgreSQLParserVALID, PostgreSQLParserVALIDATE, PostgreSQLParserVALIDATOR, PostgreSQLParserVARYING, PostgreSQLParserVERSION_P, PostgreSQLParserVIEW, PostgreSQLParserVOLATILE, PostgreSQLParserWHITESPACE_P, PostgreSQLParserWITHOUT, PostgreSQLParserWORK, PostgreSQLParserWRAPPER, PostgreSQLParserWRITE, PostgreSQLParserXML_P, PostgreSQLParserYEAR_P, PostgreSQLParserYES_P, PostgreSQLParserZONE, PostgreSQLParserBETWEEN, PostgreSQLParserBIGINT, PostgreSQLParserBIT, PostgreSQLParserBOOLEAN_P, PostgreSQLParserCHAR_P, PostgreSQLParserCHARACTER, PostgreSQLParserCOALESCE, PostgreSQLParserDEC, PostgreSQLParserDECIMAL_P, PostgreSQLParserEXISTS, PostgreSQLParserEXTRACT, PostgreSQLParserFLOAT_P, PostgreSQLParserGREATEST, PostgreSQLParserINOUT, PostgreSQLParserINT_P, PostgreSQLParserINTEGER, PostgreSQLParserINTERVAL, PostgreSQLParserLEAST, PostgreSQLParserNATIONAL, PostgreSQLParserNCHAR, PostgreSQLParserNONE, PostgreSQLParserNULLIF, PostgreSQLParserNUMERIC, PostgreSQLParserOVERLAY, PostgreSQLParserPOSITION, PostgreSQLParserPRECISION, PostgreSQLParserREAL, PostgreSQLParserROW, PostgreSQLParserSETOF, PostgreSQLParserSMALLINT, PostgreSQLParserSUBSTRING, PostgreSQLParserTIME, PostgreSQLParserTIMESTAMP, PostgreSQLParserTREAT, PostgreSQLParserTRIM, PostgreSQLParserVALUES, PostgreSQLParserVARCHAR, PostgreSQLParserXMLATTRIBUTES, PostgreSQLParserXMLCOMMENT, PostgreSQLParserXMLAGG, PostgreSQLParserXML_IS_WELL_FORMED, PostgreSQLParserXML_IS_WELL_FORMED_DOCUMENT, PostgreSQLParserXML_IS_WELL_FORMED_CONTENT, PostgreSQLParserXPATH, PostgreSQLParserXPATH_EXISTS, PostgreSQLParserXMLCONCAT, PostgreSQLParserXMLELEMENT, PostgreSQLParserXMLEXISTS, PostgreSQLParserXMLFOREST, PostgreSQLParserXMLPARSE, PostgreSQLParserXMLPI, PostgreSQLParserXMLROOT, PostgreSQLParserXMLSERIALIZE, PostgreSQLParserCALL, PostgreSQLParserCURRENT_P, PostgreSQLParserATTACH, PostgreSQLParserDETACH, PostgreSQLParserEXPRESSION, PostgreSQLParserGENERATED, PostgreSQLParserLOGGED, PostgreSQLParserSTORED, PostgreSQLParserINCLUDE, PostgreSQLParserROUTINE, PostgreSQLParserTRANSFORM, PostgreSQLParserIMPORT_P, PostgreSQLParserPOLICY, PostgreSQLParserMETHOD, PostgreSQLParserREFERENCING, PostgreSQLParserNEW, PostgreSQLParserOLD, PostgreSQLParserVALUE_P, PostgreSQLParserSUBSCRIPTION, PostgreSQLParserPUBLICATION, PostgreSQLParserOUT_P, PostgreSQLParserEND_P, PostgreSQLParserROUTINES, PostgreSQLParserSCHEMAS, PostgreSQLParserPROCEDURES, PostgreSQLParserINPUT_P, PostgreSQLParserSUPPORT, PostgreSQLParserPARALLEL, PostgreSQLParserSQL_P, PostgreSQLParserDEPENDS, PostgreSQLParserOVERRIDING, PostgreSQLParserCONFLICT, PostgreSQLParserSKIP_P, PostgreSQLParserLOCKED, PostgreSQLParserTIES, PostgreSQLParserROLLUP, PostgreSQLParserCUBE, PostgreSQLParserGROUPING, PostgreSQLParserSETS, PostgreSQLParserTABLESAMPLE, PostgreSQLParserORDINALITY, PostgreSQLParserXMLTABLE, PostgreSQLParserCOLUMNS, PostgreSQLParserXMLNAMESPACES, PostgreSQLParserROWTYPE, PostgreSQLParserNORMALIZED, PostgreSQLParserWITHIN, PostgreSQLParserFILTER, PostgreSQLParserGROUPS, PostgreSQLParserOTHERS, PostgreSQLParserNFC, PostgreSQLParserNFD, PostgreSQLParserNFKC, PostgreSQLParserNFKD, PostgreSQLParserUESCAPE, PostgreSQLParserVIEWS, PostgreSQLParserNORMALIZE, PostgreSQLParserDUMP, PostgreSQLParserPRINT_STRICT_PARAMS, PostgreSQLParserVARIABLE_CONFLICT, PostgreSQLParserERROR, PostgreSQLParserUSE_VARIABLE, PostgreSQLParserUSE_COLUMN, PostgreSQLParserALIAS, PostgreSQLParserCONSTANT, PostgreSQLParserPERFORM, PostgreSQLParserGET, PostgreSQLParserDIAGNOSTICS, PostgreSQLParserSTACKED, PostgreSQLParserELSIF, PostgreSQLParserREVERSE, PostgreSQLParserSLICE, PostgreSQLParserEXIT, PostgreSQLParserRETURN, PostgreSQLParserQUERY, PostgreSQLParserRAISE, PostgreSQLParserSQLSTATE, PostgreSQLParserDEBUG, PostgreSQLParserLOG, PostgreSQLParserINFO, PostgreSQLParserNOTICE, PostgreSQLParserWARNING, PostgreSQLParserEXCEPTION, PostgreSQLParserASSERT, PostgreSQLParserOPEN, PostgreSQLParserABS, PostgreSQLParserCBRT, PostgreSQLParserCEIL, PostgreSQLParserCEILING, PostgreSQLParserDEGREES, PostgreSQLParserDIV, PostgreSQLParserEXP, PostgreSQLParserFACTORIAL, PostgreSQLParserFLOOR, PostgreSQLParserGCD, PostgreSQLParserLCM, PostgreSQLParserLN, PostgreSQLParserLOG10, PostgreSQLParserMIN_SCALE, PostgreSQLParserMOD, PostgreSQLParserPI, PostgreSQLParserPOWER, PostgreSQLParserRADIANS, PostgreSQLParserROUND, PostgreSQLParserSCALE, PostgreSQLParserSIGN, PostgreSQLParserSQRT, PostgreSQLParserTRIM_SCALE, PostgreSQLParserTRUNC, PostgreSQLParserWIDTH_BUCKET, PostgreSQLParserRANDOM, PostgreSQLParserSETSEED, PostgreSQLParserACOS, PostgreSQLParserACOSD, PostgreSQLParserASIN, PostgreSQLParserASIND, PostgreSQLParserATAN, PostgreSQLParserATAND, PostgreSQLParserATAN2, PostgreSQLParserATAN2D, PostgreSQLParserCOS, PostgreSQLParserCOSD, PostgreSQLParserCOT, PostgreSQLParserCOTD, PostgreSQLParserSIN, PostgreSQLParserSIND, PostgreSQLParserTAN, PostgreSQLParserTAND, PostgreSQLParserSINH, PostgreSQLParserCOSH, PostgreSQLParserTANH, PostgreSQLParserASINH, PostgreSQLParserACOSH, PostgreSQLParserATANH, PostgreSQLParserBIT_LENGTH, PostgreSQLParserCHAR_LENGTH, PostgreSQLParserCHARACTER_LENGTH, PostgreSQLParserLOWER, PostgreSQLParserOCTET_LENGTH, PostgreSQLParserUPPER, PostgreSQLParserASCII, PostgreSQLParserBTRIM, PostgreSQLParserCHR, PostgreSQLParserCONCAT, PostgreSQLParserCONCAT_WS, PostgreSQLParserFORMAT, PostgreSQLParserINITCAP, PostgreSQLParserLENGTH, PostgreSQLParserLPAD, PostgreSQLParserLTRIM, PostgreSQLParserMD5, PostgreSQLParserPARSE_IDENT, PostgreSQLParserPG_CLIENT_ENCODING, PostgreSQLParserQUOTE_IDENT, PostgreSQLParserQUOTE_LITERAL, PostgreSQLParserQUOTE_NULLABLE, PostgreSQLParserREGEXP_COUNT, PostgreSQLParserREGEXP_INSTR, PostgreSQLParserREGEXP_LIKE, PostgreSQLParserREGEXP_MATCH, PostgreSQLParserREGEXP_MATCHES, PostgreSQLParserREGEXP_REPLACE, PostgreSQLParserREGEXP_SPLIT_TO_ARRAY, PostgreSQLParserREGEXP_SPLIT_TO_TABLE, PostgreSQLParserREGEXP_SUBSTR, PostgreSQLParserREPEAT, PostgreSQLParserRPAD, PostgreSQLParserRTRIM, PostgreSQLParserSPLIT_PART, PostgreSQLParserSTARTS_WITH, PostgreSQLParserSTRING_TO_ARRAY, PostgreSQLParserSTRING_TO_TABLE, PostgreSQLParserSTRPOS, PostgreSQLParserSUBSTR, PostgreSQLParserTO_ASCII, PostgreSQLParserTO_HEX, PostgreSQLParserTRANSLATE, PostgreSQLParserUNISTR, PostgreSQLParserAGE, PostgreSQLParserCLOCK_TIMESTAMP, PostgreSQLParserDATE_BIN, PostgreSQLParserDATE_PART, PostgreSQLParserDATE_TRUNC, PostgreSQLParserISFINITE, PostgreSQLParserJUSTIFY_DAYS, PostgreSQLParserJUSTIFY_HOURS, PostgreSQLParserJUSTIFY_INTERVAL, PostgreSQLParserMAKE_DATE, PostgreSQLParserMAKE_INTERVAL, PostgreSQLParserMAKE_TIME, PostgreSQLParserMAKE_TIMESTAMP, PostgreSQLParserMAKE_TIMESTAMPTZ, PostgreSQLParserNOW, PostgreSQLParserSTATEMENT_TIMESTAMP, PostgreSQLParserTIMEOFDAY, PostgreSQLParserTRANSACTION_TIMESTAMP, PostgreSQLParserTO_TIMESTAMP, PostgreSQLParserTO_CHAR, PostgreSQLParserTO_DATE, PostgreSQLParserTO_NUMBER, PostgreSQLParserIdentifier, PostgreSQLParserQuotedIdentifier, PostgreSQLParserUnicodeQuotedIdentifier, PostgreSQLParserPLSQLVARIABLENAME, PostgreSQLParserPLSQLIDENTIFIER:
			{
				p.SetState(9672)
				p.Attr_name()
			}

		case PostgreSQLParserSTAR:
			{
				p.SetState(9673)
				p.Match(PostgreSQLParserSTAR)
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}

		default:
			p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
			goto errorExit
		}

	case PostgreSQLParserOPEN_BRACKET:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(9676)
			p.Match(PostgreSQLParserOPEN_BRACKET)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		p.SetState(9682)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}

		switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 636, p.GetParserRuleContext()) {
		case 1:
			{
				p.SetState(9677)
				p.A_expr()
			}

		case 2:
			{
				p.SetState(9678)
				p.Opt_slice_bound()
			}
			{
				p.SetState(9679)
				p.Match(PostgreSQLParserCOLON)
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}
			{
				p.SetState(9680)
				p.Opt_slice_bound()
			}

		case antlr.ATNInvalidAltNumber:
			goto errorExit
		}
		{
			p.SetState(9684)
			p.Match(PostgreSQLParserCLOSE_BRACKET)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	default:
		p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IOpt_slice_boundContext is an interface to support dynamic dispatch.
type IOpt_slice_boundContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	A_expr() IA_exprContext

	// IsOpt_slice_boundContext differentiates from other interfaces.
	IsOpt_slice_boundContext()
}

type Opt_slice_boundContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyOpt_slice_boundContext() *Opt_slice_boundContext {
	var p = new(Opt_slice_boundContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opt_slice_bound
	return p
}

func InitEmptyOpt_slice_boundContext(p *Opt_slice_boundContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opt_slice_bound
}

func (*Opt_slice_boundContext) IsOpt_slice_boundContext() {}

func NewOpt_slice_boundContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_slice_boundContext {
	var p = new(Opt_slice_boundContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_opt_slice_bound

	return p
}

func (s *Opt_slice_boundContext) GetParser() antlr.Parser { return s.parser }

func (s *Opt_slice_boundContext) A_expr() IA_exprContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IA_exprContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IA_exprContext)
}

func (s *Opt_slice_boundContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Opt_slice_boundContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Opt_slice_boundContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterOpt_slice_bound(s)
	}
}

func (s *Opt_slice_boundContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitOpt_slice_bound(s)
	}
}

func (s *Opt_slice_boundContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitOpt_slice_bound(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Opt_slice_bound() (localctx IOpt_slice_boundContext) {
	localctx = NewOpt_slice_boundContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1322, PostgreSQLParserRULE_opt_slice_bound)
	p.SetState(9690)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetTokenStream().LA(1) {
	case PostgreSQLParserOPEN_PAREN, PostgreSQLParserPLUS, PostgreSQLParserMINUS, PostgreSQLParserPARAM, PostgreSQLParserOperator, PostgreSQLParserAND, PostgreSQLParserARRAY, PostgreSQLParserCASE, PostgreSQLParserCAST, PostgreSQLParserCOLLATE, PostgreSQLParserCOLUMN, PostgreSQLParserCONSTRAINT, PostgreSQLParserCURRENT_CATALOG, PostgreSQLParserCURRENT_DATE, PostgreSQLParserCURRENT_ROLE, PostgreSQLParserCURRENT_TIME, PostgreSQLParserCURRENT_TIMESTAMP, PostgreSQLParserCURRENT_USER, PostgreSQLParserDEFAULT, PostgreSQLParserDO, PostgreSQLParserFALSE_P, PostgreSQLParserFETCH, PostgreSQLParserLOCALTIME, PostgreSQLParserLOCALTIMESTAMP, PostgreSQLParserNOT, PostgreSQLParserNULL_P, PostgreSQLParserSESSION_USER, PostgreSQLParserTABLE, PostgreSQLParserTRUE_P, PostgreSQLParserUNIQUE, PostgreSQLParserUSER, PostgreSQLParserAUTHORIZATION, PostgreSQLParserBINARY, PostgreSQLParserCOLLATION, PostgreSQLParserCONCURRENTLY, PostgreSQLParserCROSS, PostgreSQLParserCURRENT_SCHEMA, PostgreSQLParserFREEZE, PostgreSQLParserFULL, PostgreSQLParserILIKE, PostgreSQLParserINNER_P, PostgreSQLParserIS, PostgreSQLParserISNULL, PostgreSQLParserJOIN, PostgreSQLParserLEFT, PostgreSQLParserLIKE, PostgreSQLParserNATURAL, PostgreSQLParserNOTNULL, PostgreSQLParserOUTER_P, PostgreSQLParserOVER, PostgreSQLParserOVERLAPS, PostgreSQLParserRIGHT, PostgreSQLParserSIMILAR, PostgreSQLParserVERBOSE, PostgreSQLParserABORT_P, PostgreSQLParserABSOLUTE_P, PostgreSQLParserACCESS, PostgreSQLParserACTION, PostgreSQLParserADD_P, PostgreSQLParserADMIN, PostgreSQLParserAFTER, PostgreSQLParserAGGREGATE, PostgreSQLParserALSO, PostgreSQLParserALTER, PostgreSQLParserALWAYS, PostgreSQLParserASSERTION, PostgreSQLParserASSIGNMENT, PostgreSQLParserAT, PostgreSQLParserATTRIBUTE, PostgreSQLParserBACKWARD, PostgreSQLParserBEFORE, PostgreSQLParserBEGIN_P, PostgreSQLParserBY, PostgreSQLParserCACHE, PostgreSQLParserCALLED, PostgreSQLParserCASCADE, PostgreSQLParserCASCADED, PostgreSQLParserCATALOG, PostgreSQLParserCHAIN, PostgreSQLParserCHARACTERISTICS, PostgreSQLParserCHECKPOINT, PostgreSQLParserCLASS, PostgreSQLParserCLOSE, PostgreSQLParserCLUSTER, PostgreSQLParserCOMMENT, PostgreSQLParserCOMMENTS, PostgreSQLParserCOMMIT, PostgreSQLParserCOMMITTED, PostgreSQLParserCONFIGURATION, PostgreSQLParserCONNECTION, PostgreSQLParserCONSTRAINTS, PostgreSQLParserCONTENT_P, PostgreSQLParserCONTINUE_P, PostgreSQLParserCONVERSION_P, PostgreSQLParserCOPY, PostgreSQLParserCOST, PostgreSQLParserCSV, PostgreSQLParserCURSOR, PostgreSQLParserCYCLE, PostgreSQLParserDATA_P, PostgreSQLParserDATABASE, PostgreSQLParserDAY_P, PostgreSQLParserDEALLOCATE, PostgreSQLParserDECLARE, PostgreSQLParserDEFAULTS, PostgreSQLParserDEFERRED, PostgreSQLParserDEFINER, PostgreSQLParserDELETE_P, PostgreSQLParserDELIMITER, PostgreSQLParserDELIMITERS, PostgreSQLParserDICTIONARY, PostgreSQLParserDISABLE_P, PostgreSQLParserDISCARD, PostgreSQLParserDOCUMENT_P, PostgreSQLParserDOMAIN_P, PostgreSQLParserDOUBLE_P, PostgreSQLParserDROP, PostgreSQLParserEACH, PostgreSQLParserENABLE_P, PostgreSQLParserENCODING, PostgreSQLParserENCRYPTED, PostgreSQLParserENUM_P, PostgreSQLParserESCAPE, PostgreSQLParserEVENT, PostgreSQLParserEXCLUDE, PostgreSQLParserEXCLUDING, PostgreSQLParserEXCLUSIVE, PostgreSQLParserEXECUTE, PostgreSQLParserEXPLAIN, PostgreSQLParserEXTENSION, PostgreSQLParserEXTERNAL, PostgreSQLParserFAMILY, PostgreSQLParserFIRST_P, PostgreSQLParserFOLLOWING, PostgreSQLParserFORCE, PostgreSQLParserFORWARD, PostgreSQLParserFUNCTION, PostgreSQLParserFUNCTIONS, PostgreSQLParserGLOBAL, PostgreSQLParserGRANTED, PostgreSQLParserHANDLER, PostgreSQLParserHEADER_P, PostgreSQLParserHOLD, PostgreSQLParserHOUR_P, PostgreSQLParserIDENTITY_P, PostgreSQLParserIF_P, PostgreSQLParserIMMEDIATE, PostgreSQLParserIMMUTABLE, PostgreSQLParserIMPLICIT_P, PostgreSQLParserINCLUDING, PostgreSQLParserINCREMENT, PostgreSQLParserINDEX, PostgreSQLParserINDEXES, PostgreSQLParserINHERIT, PostgreSQLParserINHERITS, PostgreSQLParserINLINE_P, PostgreSQLParserINSENSITIVE, PostgreSQLParserINSERT, PostgreSQLParserINSTEAD, PostgreSQLParserINVOKER, PostgreSQLParserISOLATION, PostgreSQLParserKEY, PostgreSQLParserLABEL, PostgreSQLParserLANGUAGE, PostgreSQLParserLARGE_P, PostgreSQLParserLAST_P, PostgreSQLParserLEAKPROOF, PostgreSQLParserLEVEL, PostgreSQLParserLISTEN, PostgreSQLParserLOAD, PostgreSQLParserLOCAL, PostgreSQLParserLOCATION, PostgreSQLParserLOCK_P, PostgreSQLParserMAPPING, PostgreSQLParserMATCH, PostgreSQLParserMATERIALIZED, PostgreSQLParserMAXVALUE, PostgreSQLParserMINUTE_P, PostgreSQLParserMINVALUE, PostgreSQLParserMODE, PostgreSQLParserMONTH_P, PostgreSQLParserMOVE, PostgreSQLParserNAME_P, PostgreSQLParserNAMES, PostgreSQLParserNEXT, PostgreSQLParserNO, PostgreSQLParserNOTHING, PostgreSQLParserNOTIFY, PostgreSQLParserNOWAIT, PostgreSQLParserNULLS_P, PostgreSQLParserOBJECT_P, PostgreSQLParserOF, PostgreSQLParserOFF, PostgreSQLParserOIDS, PostgreSQLParserOPERATOR, PostgreSQLParserOPTION, PostgreSQLParserOPTIONS, PostgreSQLParserOWNED, PostgreSQLParserOWNER, PostgreSQLParserPARSER, PostgreSQLParserPARTIAL, PostgreSQLParserPARTITION, PostgreSQLParserPASSING, PostgreSQLParserPASSWORD, PostgreSQLParserPLANS, PostgreSQLParserPRECEDING, PostgreSQLParserPREPARE, PostgreSQLParserPREPARED, PostgreSQLParserPRESERVE, PostgreSQLParserPRIOR, PostgreSQLParserPRIVILEGES, PostgreSQLParserPROCEDURAL, PostgreSQLParserPROCEDURE, PostgreSQLParserPROGRAM, PostgreSQLParserQUOTE, PostgreSQLParserRANGE, PostgreSQLParserREAD, PostgreSQLParserREASSIGN, PostgreSQLParserRECHECK, PostgreSQLParserRECURSIVE, PostgreSQLParserREF, PostgreSQLParserREFRESH, PostgreSQLParserREINDEX, PostgreSQLParserRELATIVE_P, PostgreSQLParserRELEASE, PostgreSQLParserRENAME, PostgreSQLParserREPEATABLE, PostgreSQLParserREPLACE, PostgreSQLParserREPLICA, PostgreSQLParserRESET, PostgreSQLParserRESTART, PostgreSQLParserRESTRICT, PostgreSQLParserRETURNS, PostgreSQLParserREVOKE, PostgreSQLParserROLE, PostgreSQLParserROLLBACK, PostgreSQLParserROWS, PostgreSQLParserRULE, PostgreSQLParserSAVEPOINT, PostgreSQLParserSCHEMA, PostgreSQLParserSCROLL, PostgreSQLParserSEARCH, PostgreSQLParserSECOND_P, PostgreSQLParserSECURITY, PostgreSQLParserSEQUENCE, PostgreSQLParserSEQUENCES, PostgreSQLParserSERIALIZABLE, PostgreSQLParserSERVER, PostgreSQLParserSESSION, PostgreSQLParserSET, PostgreSQLParserSHARE, PostgreSQLParserSHOW, PostgreSQLParserSIMPLE, PostgreSQLParserSNAPSHOT, PostgreSQLParserSTABLE, PostgreSQLParserSTANDALONE_P, PostgreSQLParserSTART, PostgreSQLParserSTATEMENT, PostgreSQLParserSTATISTICS, PostgreSQLParserSTDIN, PostgreSQLParserSTDOUT, PostgreSQLParserSTORAGE, PostgreSQLParserSTRICT_P, PostgreSQLParserSTRIP_P, PostgreSQLParserSYSID, PostgreSQLParserSYSTEM_P, PostgreSQLParserTABLES, PostgreSQLParserTABLESPACE, PostgreSQLParserTEMP, PostgreSQLParserTEMPLATE, PostgreSQLParserTEMPORARY, PostgreSQLParserTEXT_P, PostgreSQLParserTRANSACTION, PostgreSQLParserTRIGGER, PostgreSQLParserTRUNCATE, PostgreSQLParserTRUSTED, PostgreSQLParserTYPE_P, PostgreSQLParserTYPES_P, PostgreSQLParserUNBOUNDED, PostgreSQLParserUNCOMMITTED, PostgreSQLParserUNENCRYPTED, PostgreSQLParserUNKNOWN, PostgreSQLParserUNLISTEN, PostgreSQLParserUNLOGGED, PostgreSQLParserUNTIL, PostgreSQLParserUPDATE, PostgreSQLParserVACUUM, PostgreSQLParserVALID, PostgreSQLParserVALIDATE, PostgreSQLParserVALIDATOR, PostgreSQLParserVARYING, PostgreSQLParserVERSION_P, PostgreSQLParserVIEW, PostgreSQLParserVOLATILE, PostgreSQLParserWHITESPACE_P, PostgreSQLParserWITHOUT, PostgreSQLParserWORK, PostgreSQLParserWRAPPER, PostgreSQLParserWRITE, PostgreSQLParserXML_P, PostgreSQLParserYEAR_P, PostgreSQLParserYES_P, PostgreSQLParserZONE, PostgreSQLParserBETWEEN, PostgreSQLParserBIGINT, PostgreSQLParserBIT, PostgreSQLParserBOOLEAN_P, PostgreSQLParserCHAR_P, PostgreSQLParserCHARACTER, PostgreSQLParserCOALESCE, PostgreSQLParserDEC, PostgreSQLParserDECIMAL_P, PostgreSQLParserEXISTS, PostgreSQLParserEXTRACT, PostgreSQLParserFLOAT_P, PostgreSQLParserGREATEST, PostgreSQLParserINOUT, PostgreSQLParserINT_P, PostgreSQLParserINTEGER, PostgreSQLParserINTERVAL, PostgreSQLParserLEAST, PostgreSQLParserNATIONAL, PostgreSQLParserNCHAR, PostgreSQLParserNONE, PostgreSQLParserNULLIF, PostgreSQLParserNUMERIC, PostgreSQLParserOVERLAY, PostgreSQLParserPOSITION, PostgreSQLParserPRECISION, PostgreSQLParserREAL, PostgreSQLParserROW, PostgreSQLParserSETOF, PostgreSQLParserSMALLINT, PostgreSQLParserSUBSTRING, PostgreSQLParserTIME, PostgreSQLParserTIMESTAMP, PostgreSQLParserTREAT, PostgreSQLParserTRIM, PostgreSQLParserVALUES, PostgreSQLParserVARCHAR, PostgreSQLParserXMLATTRIBUTES, PostgreSQLParserXMLCOMMENT, PostgreSQLParserXMLAGG, PostgreSQLParserXML_IS_WELL_FORMED, PostgreSQLParserXML_IS_WELL_FORMED_DOCUMENT, PostgreSQLParserXML_IS_WELL_FORMED_CONTENT, PostgreSQLParserXPATH, PostgreSQLParserXPATH_EXISTS, PostgreSQLParserXMLCONCAT, PostgreSQLParserXMLELEMENT, PostgreSQLParserXMLEXISTS, PostgreSQLParserXMLFOREST, PostgreSQLParserXMLPARSE, PostgreSQLParserXMLPI, PostgreSQLParserXMLROOT, PostgreSQLParserXMLSERIALIZE, PostgreSQLParserCALL, PostgreSQLParserCURRENT_P, PostgreSQLParserATTACH, PostgreSQLParserDETACH, PostgreSQLParserEXPRESSION, PostgreSQLParserGENERATED, PostgreSQLParserLOGGED, PostgreSQLParserSTORED, PostgreSQLParserINCLUDE, PostgreSQLParserROUTINE, PostgreSQLParserTRANSFORM, PostgreSQLParserIMPORT_P, PostgreSQLParserPOLICY, PostgreSQLParserMETHOD, PostgreSQLParserREFERENCING, PostgreSQLParserNEW, PostgreSQLParserOLD, PostgreSQLParserVALUE_P, PostgreSQLParserSUBSCRIPTION, PostgreSQLParserPUBLICATION, PostgreSQLParserOUT_P, PostgreSQLParserROUTINES, PostgreSQLParserSCHEMAS, PostgreSQLParserPROCEDURES, PostgreSQLParserINPUT_P, PostgreSQLParserSUPPORT, PostgreSQLParserPARALLEL, PostgreSQLParserSQL_P, PostgreSQLParserDEPENDS, PostgreSQLParserOVERRIDING, PostgreSQLParserCONFLICT, PostgreSQLParserSKIP_P, PostgreSQLParserLOCKED, PostgreSQLParserTIES, PostgreSQLParserROLLUP, PostgreSQLParserCUBE, PostgreSQLParserGROUPING, PostgreSQLParserSETS, PostgreSQLParserTABLESAMPLE, PostgreSQLParserORDINALITY, PostgreSQLParserXMLTABLE, PostgreSQLParserCOLUMNS, PostgreSQLParserXMLNAMESPACES, PostgreSQLParserROWTYPE, PostgreSQLParserNORMALIZED, PostgreSQLParserWITHIN, PostgreSQLParserFILTER, PostgreSQLParserGROUPS, PostgreSQLParserOTHERS, PostgreSQLParserNFC, PostgreSQLParserNFD, PostgreSQLParserNFKC, PostgreSQLParserNFKD, PostgreSQLParserUESCAPE, PostgreSQLParserVIEWS, PostgreSQLParserNORMALIZE, PostgreSQLParserDUMP, PostgreSQLParserPRINT_STRICT_PARAMS, PostgreSQLParserVARIABLE_CONFLICT, PostgreSQLParserERROR, PostgreSQLParserUSE_VARIABLE, PostgreSQLParserUSE_COLUMN, PostgreSQLParserALIAS, PostgreSQLParserCONSTANT, PostgreSQLParserPERFORM, PostgreSQLParserGET, PostgreSQLParserDIAGNOSTICS, PostgreSQLParserSTACKED, PostgreSQLParserELSIF, PostgreSQLParserREVERSE, PostgreSQLParserSLICE, PostgreSQLParserEXIT, PostgreSQLParserRETURN, PostgreSQLParserQUERY, PostgreSQLParserRAISE, PostgreSQLParserSQLSTATE, PostgreSQLParserDEBUG, PostgreSQLParserLOG, PostgreSQLParserINFO, PostgreSQLParserNOTICE, PostgreSQLParserWARNING, PostgreSQLParserEXCEPTION, PostgreSQLParserASSERT, PostgreSQLParserOPEN, PostgreSQLParserABS, PostgreSQLParserCBRT, PostgreSQLParserCEIL, PostgreSQLParserCEILING, PostgreSQLParserDEGREES, PostgreSQLParserDIV, PostgreSQLParserEXP, PostgreSQLParserFACTORIAL, PostgreSQLParserFLOOR, PostgreSQLParserGCD, PostgreSQLParserLCM, PostgreSQLParserLN, PostgreSQLParserLOG10, PostgreSQLParserMIN_SCALE, PostgreSQLParserMOD, PostgreSQLParserPI, PostgreSQLParserPOWER, PostgreSQLParserRADIANS, PostgreSQLParserROUND, PostgreSQLParserSCALE, PostgreSQLParserSIGN, PostgreSQLParserSQRT, PostgreSQLParserTRIM_SCALE, PostgreSQLParserTRUNC, PostgreSQLParserWIDTH_BUCKET, PostgreSQLParserRANDOM, PostgreSQLParserSETSEED, PostgreSQLParserACOS, PostgreSQLParserACOSD, PostgreSQLParserASIN, PostgreSQLParserASIND, PostgreSQLParserATAN, PostgreSQLParserATAND, PostgreSQLParserATAN2, PostgreSQLParserATAN2D, PostgreSQLParserCOS, PostgreSQLParserCOSD, PostgreSQLParserCOT, PostgreSQLParserCOTD, PostgreSQLParserSIN, PostgreSQLParserSIND, PostgreSQLParserTAN, PostgreSQLParserTAND, PostgreSQLParserSINH, PostgreSQLParserCOSH, PostgreSQLParserTANH, PostgreSQLParserASINH, PostgreSQLParserACOSH, PostgreSQLParserATANH, PostgreSQLParserBIT_LENGTH, PostgreSQLParserCHAR_LENGTH, PostgreSQLParserCHARACTER_LENGTH, PostgreSQLParserLOWER, PostgreSQLParserOCTET_LENGTH, PostgreSQLParserUPPER, PostgreSQLParserASCII, PostgreSQLParserBTRIM, PostgreSQLParserCHR, PostgreSQLParserCONCAT, PostgreSQLParserCONCAT_WS, PostgreSQLParserFORMAT, PostgreSQLParserINITCAP, PostgreSQLParserLENGTH, PostgreSQLParserLPAD, PostgreSQLParserLTRIM, PostgreSQLParserMD5, PostgreSQLParserPARSE_IDENT, PostgreSQLParserPG_CLIENT_ENCODING, PostgreSQLParserQUOTE_IDENT, PostgreSQLParserQUOTE_LITERAL, PostgreSQLParserQUOTE_NULLABLE, PostgreSQLParserREGEXP_COUNT, PostgreSQLParserREGEXP_INSTR, PostgreSQLParserREGEXP_LIKE, PostgreSQLParserREGEXP_MATCH, PostgreSQLParserREGEXP_MATCHES, PostgreSQLParserREGEXP_REPLACE, PostgreSQLParserREGEXP_SPLIT_TO_ARRAY, PostgreSQLParserREGEXP_SPLIT_TO_TABLE, PostgreSQLParserREGEXP_SUBSTR, PostgreSQLParserREPEAT, PostgreSQLParserRPAD, PostgreSQLParserRTRIM, PostgreSQLParserSPLIT_PART, PostgreSQLParserSTARTS_WITH, PostgreSQLParserSTRING_TO_ARRAY, PostgreSQLParserSTRING_TO_TABLE, PostgreSQLParserSTRPOS, PostgreSQLParserSUBSTR, PostgreSQLParserTO_ASCII, PostgreSQLParserTO_HEX, PostgreSQLParserTRANSLATE, PostgreSQLParserUNISTR, PostgreSQLParserAGE, PostgreSQLParserCLOCK_TIMESTAMP, PostgreSQLParserDATE_BIN, PostgreSQLParserDATE_PART, PostgreSQLParserDATE_TRUNC, PostgreSQLParserISFINITE, PostgreSQLParserJUSTIFY_DAYS, PostgreSQLParserJUSTIFY_HOURS, PostgreSQLParserJUSTIFY_INTERVAL, PostgreSQLParserMAKE_DATE, PostgreSQLParserMAKE_INTERVAL, PostgreSQLParserMAKE_TIME, PostgreSQLParserMAKE_TIMESTAMP, PostgreSQLParserMAKE_TIMESTAMPTZ, PostgreSQLParserNOW, PostgreSQLParserSTATEMENT_TIMESTAMP, PostgreSQLParserTIMEOFDAY, PostgreSQLParserTRANSACTION_TIMESTAMP, PostgreSQLParserTO_TIMESTAMP, PostgreSQLParserTO_CHAR, PostgreSQLParserTO_DATE, PostgreSQLParserTO_NUMBER, PostgreSQLParserIdentifier, PostgreSQLParserQuotedIdentifier, PostgreSQLParserUnicodeQuotedIdentifier, PostgreSQLParserStringConstant, PostgreSQLParserUnicodeEscapeStringConstant, PostgreSQLParserBeginDollarStringConstant, PostgreSQLParserBinaryStringConstant, PostgreSQLParserHexadecimalStringConstant, PostgreSQLParserIntegral, PostgreSQLParserNumeric, PostgreSQLParserPLSQLVARIABLENAME, PostgreSQLParserPLSQLIDENTIFIER, PostgreSQLParserEscapeStringConstant:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(9688)
			p.A_expr()
		}

	case PostgreSQLParserCLOSE_BRACKET, PostgreSQLParserCOLON:
		p.EnterOuterAlt(localctx, 2)

	default:
		p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IIndirectionContext is an interface to support dynamic dispatch.
type IIndirectionContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	AllIndirection_el() []IIndirection_elContext
	Indirection_el(i int) IIndirection_elContext

	// IsIndirectionContext differentiates from other interfaces.
	IsIndirectionContext()
}

type IndirectionContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyIndirectionContext() *IndirectionContext {
	var p = new(IndirectionContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_indirection
	return p
}

func InitEmptyIndirectionContext(p *IndirectionContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_indirection
}

func (*IndirectionContext) IsIndirectionContext() {}

func NewIndirectionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *IndirectionContext {
	var p = new(IndirectionContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_indirection

	return p
}

func (s *IndirectionContext) GetParser() antlr.Parser { return s.parser }

func (s *IndirectionContext) AllIndirection_el() []IIndirection_elContext {
	children := s.GetChildren()
	len := 0
	for _, ctx := range children {
		if _, ok := ctx.(IIndirection_elContext); ok {
			len++
		}
	}

	tst := make([]IIndirection_elContext, len)
	i := 0
	for _, ctx := range children {
		if t, ok := ctx.(IIndirection_elContext); ok {
			tst[i] = t.(IIndirection_elContext)
			i++
		}
	}

	return tst
}

func (s *IndirectionContext) Indirection_el(i int) IIndirection_elContext {
	var t antlr.RuleContext
	j := 0
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IIndirection_elContext); ok {
			if j == i {
				t = ctx.(antlr.RuleContext)
				break
			}
			j++
		}
	}

	if t == nil {
		return nil
	}

	return t.(IIndirection_elContext)
}

func (s *IndirectionContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *IndirectionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *IndirectionContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterIndirection(s)
	}
}

func (s *IndirectionContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitIndirection(s)
	}
}

func (s *IndirectionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitIndirection(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Indirection() (localctx IIndirectionContext) {
	localctx = NewIndirectionContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1324, PostgreSQLParserRULE_indirection)
	var _alt int

	p.EnterOuterAlt(localctx, 1)
	p.SetState(9693)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}
	_alt = 1
	for ok := true; ok; ok = _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
		switch _alt {
		case 1:
			{
				p.SetState(9692)
				p.Indirection_el()
			}

		default:
			p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
			goto errorExit
		}

		p.SetState(9695)
		p.GetErrorHandler().Sync(p)
		_alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 639, p.GetParserRuleContext())
		if p.HasError() {
			goto errorExit
		}
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IOpt_indirectionContext is an interface to support dynamic dispatch.
type IOpt_indirectionContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	AllIndirection_el() []IIndirection_elContext
	Indirection_el(i int) IIndirection_elContext

	// IsOpt_indirectionContext differentiates from other interfaces.
	IsOpt_indirectionContext()
}

type Opt_indirectionContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyOpt_indirectionContext() *Opt_indirectionContext {
	var p = new(Opt_indirectionContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opt_indirection
	return p
}

func InitEmptyOpt_indirectionContext(p *Opt_indirectionContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opt_indirection
}

func (*Opt_indirectionContext) IsOpt_indirectionContext() {}

func NewOpt_indirectionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_indirectionContext {
	var p = new(Opt_indirectionContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_opt_indirection

	return p
}

func (s *Opt_indirectionContext) GetParser() antlr.Parser { return s.parser }

func (s *Opt_indirectionContext) AllIndirection_el() []IIndirection_elContext {
	children := s.GetChildren()
	len := 0
	for _, ctx := range children {
		if _, ok := ctx.(IIndirection_elContext); ok {
			len++
		}
	}

	tst := make([]IIndirection_elContext, len)
	i := 0
	for _, ctx := range children {
		if t, ok := ctx.(IIndirection_elContext); ok {
			tst[i] = t.(IIndirection_elContext)
			i++
		}
	}

	return tst
}

func (s *Opt_indirectionContext) Indirection_el(i int) IIndirection_elContext {
	var t antlr.RuleContext
	j := 0
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IIndirection_elContext); ok {
			if j == i {
				t = ctx.(antlr.RuleContext)
				break
			}
			j++
		}
	}

	if t == nil {
		return nil
	}

	return t.(IIndirection_elContext)
}

func (s *Opt_indirectionContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Opt_indirectionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Opt_indirectionContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterOpt_indirection(s)
	}
}

func (s *Opt_indirectionContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitOpt_indirection(s)
	}
}

func (s *Opt_indirectionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitOpt_indirection(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Opt_indirection() (localctx IOpt_indirectionContext) {
	localctx = NewOpt_indirectionContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1326, PostgreSQLParserRULE_opt_indirection)
	var _alt int

	p.EnterOuterAlt(localctx, 1)
	p.SetState(9700)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}
	_alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 640, p.GetParserRuleContext())
	if p.HasError() {
		goto errorExit
	}
	for _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
		if _alt == 1 {
			{
				p.SetState(9697)
				p.Indirection_el()
			}

		}
		p.SetState(9702)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}
		_alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 640, p.GetParserRuleContext())
		if p.HasError() {
			goto errorExit
		}
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IOpt_target_listContext is an interface to support dynamic dispatch.
type IOpt_target_listContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Target_list() ITarget_listContext

	// IsOpt_target_listContext differentiates from other interfaces.
	IsOpt_target_listContext()
}

type Opt_target_listContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyOpt_target_listContext() *Opt_target_listContext {
	var p = new(Opt_target_listContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opt_target_list
	return p
}

func InitEmptyOpt_target_listContext(p *Opt_target_listContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opt_target_list
}

func (*Opt_target_listContext) IsOpt_target_listContext() {}

func NewOpt_target_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_target_listContext {
	var p = new(Opt_target_listContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_opt_target_list

	return p
}

func (s *Opt_target_listContext) GetParser() antlr.Parser { return s.parser }

func (s *Opt_target_listContext) Target_list() ITarget_listContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ITarget_listContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ITarget_listContext)
}

func (s *Opt_target_listContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Opt_target_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Opt_target_listContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterOpt_target_list(s)
	}
}

func (s *Opt_target_listContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitOpt_target_list(s)
	}
}

func (s *Opt_target_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitOpt_target_list(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Opt_target_list() (localctx IOpt_target_listContext) {
	localctx = NewOpt_target_listContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1328, PostgreSQLParserRULE_opt_target_list)
	p.SetState(9705)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 641, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(9703)
			p.Target_list()
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)

	case antlr.ATNInvalidAltNumber:
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// ITarget_listContext is an interface to support dynamic dispatch.
type ITarget_listContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	AllTarget_el() []ITarget_elContext
	Target_el(i int) ITarget_elContext
	AllCOMMA() []antlr.TerminalNode
	COMMA(i int) antlr.TerminalNode

	// IsTarget_listContext differentiates from other interfaces.
	IsTarget_listContext()
}

type Target_listContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyTarget_listContext() *Target_listContext {
	var p = new(Target_listContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_target_list
	return p
}

func InitEmptyTarget_listContext(p *Target_listContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_target_list
}

func (*Target_listContext) IsTarget_listContext() {}

func NewTarget_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Target_listContext {
	var p = new(Target_listContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_target_list

	return p
}

func (s *Target_listContext) GetParser() antlr.Parser { return s.parser }

func (s *Target_listContext) AllTarget_el() []ITarget_elContext {
	children := s.GetChildren()
	len := 0
	for _, ctx := range children {
		if _, ok := ctx.(ITarget_elContext); ok {
			len++
		}
	}

	tst := make([]ITarget_elContext, len)
	i := 0
	for _, ctx := range children {
		if t, ok := ctx.(ITarget_elContext); ok {
			tst[i] = t.(ITarget_elContext)
			i++
		}
	}

	return tst
}

func (s *Target_listContext) Target_el(i int) ITarget_elContext {
	var t antlr.RuleContext
	j := 0
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ITarget_elContext); ok {
			if j == i {
				t = ctx.(antlr.RuleContext)
				break
			}
			j++
		}
	}

	if t == nil {
		return nil
	}

	return t.(ITarget_elContext)
}

func (s *Target_listContext) AllCOMMA() []antlr.TerminalNode {
	return s.GetTokens(PostgreSQLParserCOMMA)
}

func (s *Target_listContext) COMMA(i int) antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCOMMA, i)
}

func (s *Target_listContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Target_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Target_listContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterTarget_list(s)
	}
}

func (s *Target_listContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitTarget_list(s)
	}
}

func (s *Target_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitTarget_list(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Target_list() (localctx ITarget_listContext) {
	localctx = NewTarget_listContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1330, PostgreSQLParserRULE_target_list)
	var _alt int

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(9707)
		p.Target_el()
	}
	p.SetState(9712)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}
	_alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 642, p.GetParserRuleContext())
	if p.HasError() {
		goto errorExit
	}
	for _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
		if _alt == 1 {
			{
				p.SetState(9708)
				p.Match(PostgreSQLParserCOMMA)
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}
			{
				p.SetState(9709)
				p.Target_el()
			}

		}
		p.SetState(9714)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}
		_alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 642, p.GetParserRuleContext())
		if p.HasError() {
			goto errorExit
		}
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// ITarget_elContext is an interface to support dynamic dispatch.
type ITarget_elContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser
	// IsTarget_elContext differentiates from other interfaces.
	IsTarget_elContext()
}

type Target_elContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyTarget_elContext() *Target_elContext {
	var p = new(Target_elContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_target_el
	return p
}

func InitEmptyTarget_elContext(p *Target_elContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_target_el
}

func (*Target_elContext) IsTarget_elContext() {}

func NewTarget_elContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Target_elContext {
	var p = new(Target_elContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_target_el

	return p
}

func (s *Target_elContext) GetParser() antlr.Parser { return s.parser }

func (s *Target_elContext) CopyAll(ctx *Target_elContext) {
	s.CopyFrom(&ctx.BaseParserRuleContext)
}

func (s *Target_elContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Target_elContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

type Target_labelContext struct {
	Target_elContext
}

func NewTarget_labelContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *Target_labelContext {
	var p = new(Target_labelContext)

	InitEmptyTarget_elContext(&p.Target_elContext)
	p.parser = parser
	p.CopyAll(ctx.(*Target_elContext))

	return p
}

func (s *Target_labelContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Target_labelContext) A_expr() IA_exprContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IA_exprContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IA_exprContext)
}

func (s *Target_labelContext) AS() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserAS, 0)
}

func (s *Target_labelContext) Collabel() ICollabelContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ICollabelContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ICollabelContext)
}

func (s *Target_labelContext) Identifier() IIdentifierContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IIdentifierContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IIdentifierContext)
}

func (s *Target_labelContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterTarget_label(s)
	}
}

func (s *Target_labelContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitTarget_label(s)
	}
}

func (s *Target_labelContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitTarget_label(s)

	default:
		return t.VisitChildren(s)
	}
}

type Target_starContext struct {
	Target_elContext
}

func NewTarget_starContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *Target_starContext {
	var p = new(Target_starContext)

	InitEmptyTarget_elContext(&p.Target_elContext)
	p.parser = parser
	p.CopyAll(ctx.(*Target_elContext))

	return p
}

func (s *Target_starContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Target_starContext) STAR() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserSTAR, 0)
}

func (s *Target_starContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterTarget_star(s)
	}
}

func (s *Target_starContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitTarget_star(s)
	}
}

func (s *Target_starContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitTarget_star(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Target_el() (localctx ITarget_elContext) {
	localctx = NewTarget_elContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1332, PostgreSQLParserRULE_target_el)
	p.SetState(9723)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetTokenStream().LA(1) {
	case PostgreSQLParserOPEN_PAREN, PostgreSQLParserPLUS, PostgreSQLParserMINUS, PostgreSQLParserPARAM, PostgreSQLParserOperator, PostgreSQLParserAND, PostgreSQLParserARRAY, PostgreSQLParserCASE, PostgreSQLParserCAST, PostgreSQLParserCOLLATE, PostgreSQLParserCOLUMN, PostgreSQLParserCONSTRAINT, PostgreSQLParserCURRENT_CATALOG, PostgreSQLParserCURRENT_DATE, PostgreSQLParserCURRENT_ROLE, PostgreSQLParserCURRENT_TIME, PostgreSQLParserCURRENT_TIMESTAMP, PostgreSQLParserCURRENT_USER, PostgreSQLParserDEFAULT, PostgreSQLParserDO, PostgreSQLParserFALSE_P, PostgreSQLParserFETCH, PostgreSQLParserLOCALTIME, PostgreSQLParserLOCALTIMESTAMP, PostgreSQLParserNOT, PostgreSQLParserNULL_P, PostgreSQLParserSESSION_USER, PostgreSQLParserTABLE, PostgreSQLParserTRUE_P, PostgreSQLParserUNIQUE, PostgreSQLParserUSER, PostgreSQLParserAUTHORIZATION, PostgreSQLParserBINARY, PostgreSQLParserCOLLATION, PostgreSQLParserCONCURRENTLY, PostgreSQLParserCROSS, PostgreSQLParserCURRENT_SCHEMA, PostgreSQLParserFREEZE, PostgreSQLParserFULL, PostgreSQLParserILIKE, PostgreSQLParserINNER_P, PostgreSQLParserIS, PostgreSQLParserISNULL, PostgreSQLParserJOIN, PostgreSQLParserLEFT, PostgreSQLParserLIKE, PostgreSQLParserNATURAL, PostgreSQLParserNOTNULL, PostgreSQLParserOUTER_P, PostgreSQLParserOVER, PostgreSQLParserOVERLAPS, PostgreSQLParserRIGHT, PostgreSQLParserSIMILAR, PostgreSQLParserVERBOSE, PostgreSQLParserABORT_P, PostgreSQLParserABSOLUTE_P, PostgreSQLParserACCESS, PostgreSQLParserACTION, PostgreSQLParserADD_P, PostgreSQLParserADMIN, PostgreSQLParserAFTER, PostgreSQLParserAGGREGATE, PostgreSQLParserALSO, PostgreSQLParserALTER, PostgreSQLParserALWAYS, PostgreSQLParserASSERTION, PostgreSQLParserASSIGNMENT, PostgreSQLParserAT, PostgreSQLParserATTRIBUTE, PostgreSQLParserBACKWARD, PostgreSQLParserBEFORE, PostgreSQLParserBEGIN_P, PostgreSQLParserBY, PostgreSQLParserCACHE, PostgreSQLParserCALLED, PostgreSQLParserCASCADE, PostgreSQLParserCASCADED, PostgreSQLParserCATALOG, PostgreSQLParserCHAIN, PostgreSQLParserCHARACTERISTICS, PostgreSQLParserCHECKPOINT, PostgreSQLParserCLASS, PostgreSQLParserCLOSE, PostgreSQLParserCLUSTER, PostgreSQLParserCOMMENT, PostgreSQLParserCOMMENTS, PostgreSQLParserCOMMIT, PostgreSQLParserCOMMITTED, PostgreSQLParserCONFIGURATION, PostgreSQLParserCONNECTION, PostgreSQLParserCONSTRAINTS, PostgreSQLParserCONTENT_P, PostgreSQLParserCONTINUE_P, PostgreSQLParserCONVERSION_P, PostgreSQLParserCOPY, PostgreSQLParserCOST, PostgreSQLParserCSV, PostgreSQLParserCURSOR, PostgreSQLParserCYCLE, PostgreSQLParserDATA_P, PostgreSQLParserDATABASE, PostgreSQLParserDAY_P, PostgreSQLParserDEALLOCATE, PostgreSQLParserDECLARE, PostgreSQLParserDEFAULTS, PostgreSQLParserDEFERRED, PostgreSQLParserDEFINER, PostgreSQLParserDELETE_P, PostgreSQLParserDELIMITER, PostgreSQLParserDELIMITERS, PostgreSQLParserDICTIONARY, PostgreSQLParserDISABLE_P, PostgreSQLParserDISCARD, PostgreSQLParserDOCUMENT_P, PostgreSQLParserDOMAIN_P, PostgreSQLParserDOUBLE_P, PostgreSQLParserDROP, PostgreSQLParserEACH, PostgreSQLParserENABLE_P, PostgreSQLParserENCODING, PostgreSQLParserENCRYPTED, PostgreSQLParserENUM_P, PostgreSQLParserESCAPE, PostgreSQLParserEVENT, PostgreSQLParserEXCLUDE, PostgreSQLParserEXCLUDING, PostgreSQLParserEXCLUSIVE, PostgreSQLParserEXECUTE, PostgreSQLParserEXPLAIN, PostgreSQLParserEXTENSION, PostgreSQLParserEXTERNAL, PostgreSQLParserFAMILY, PostgreSQLParserFIRST_P, PostgreSQLParserFOLLOWING, PostgreSQLParserFORCE, PostgreSQLParserFORWARD, PostgreSQLParserFUNCTION, PostgreSQLParserFUNCTIONS, PostgreSQLParserGLOBAL, PostgreSQLParserGRANTED, PostgreSQLParserHANDLER, PostgreSQLParserHEADER_P, PostgreSQLParserHOLD, PostgreSQLParserHOUR_P, PostgreSQLParserIDENTITY_P, PostgreSQLParserIF_P, PostgreSQLParserIMMEDIATE, PostgreSQLParserIMMUTABLE, PostgreSQLParserIMPLICIT_P, PostgreSQLParserINCLUDING, PostgreSQLParserINCREMENT, PostgreSQLParserINDEX, PostgreSQLParserINDEXES, PostgreSQLParserINHERIT, PostgreSQLParserINHERITS, PostgreSQLParserINLINE_P, PostgreSQLParserINSENSITIVE, PostgreSQLParserINSERT, PostgreSQLParserINSTEAD, PostgreSQLParserINVOKER, PostgreSQLParserISOLATION, PostgreSQLParserKEY, PostgreSQLParserLABEL, PostgreSQLParserLANGUAGE, PostgreSQLParserLARGE_P, PostgreSQLParserLAST_P, PostgreSQLParserLEAKPROOF, PostgreSQLParserLEVEL, PostgreSQLParserLISTEN, PostgreSQLParserLOAD, PostgreSQLParserLOCAL, PostgreSQLParserLOCATION, PostgreSQLParserLOCK_P, PostgreSQLParserMAPPING, PostgreSQLParserMATCH, PostgreSQLParserMATERIALIZED, PostgreSQLParserMAXVALUE, PostgreSQLParserMINUTE_P, PostgreSQLParserMINVALUE, PostgreSQLParserMODE, PostgreSQLParserMONTH_P, PostgreSQLParserMOVE, PostgreSQLParserNAME_P, PostgreSQLParserNAMES, PostgreSQLParserNEXT, PostgreSQLParserNO, PostgreSQLParserNOTHING, PostgreSQLParserNOTIFY, PostgreSQLParserNOWAIT, PostgreSQLParserNULLS_P, PostgreSQLParserOBJECT_P, PostgreSQLParserOF, PostgreSQLParserOFF, PostgreSQLParserOIDS, PostgreSQLParserOPERATOR, PostgreSQLParserOPTION, PostgreSQLParserOPTIONS, PostgreSQLParserOWNED, PostgreSQLParserOWNER, PostgreSQLParserPARSER, PostgreSQLParserPARTIAL, PostgreSQLParserPARTITION, PostgreSQLParserPASSING, PostgreSQLParserPASSWORD, PostgreSQLParserPLANS, PostgreSQLParserPRECEDING, PostgreSQLParserPREPARE, PostgreSQLParserPREPARED, PostgreSQLParserPRESERVE, PostgreSQLParserPRIOR, PostgreSQLParserPRIVILEGES, PostgreSQLParserPROCEDURAL, PostgreSQLParserPROCEDURE, PostgreSQLParserPROGRAM, PostgreSQLParserQUOTE, PostgreSQLParserRANGE, PostgreSQLParserREAD, PostgreSQLParserREASSIGN, PostgreSQLParserRECHECK, PostgreSQLParserRECURSIVE, PostgreSQLParserREF, PostgreSQLParserREFRESH, PostgreSQLParserREINDEX, PostgreSQLParserRELATIVE_P, PostgreSQLParserRELEASE, PostgreSQLParserRENAME, PostgreSQLParserREPEATABLE, PostgreSQLParserREPLACE, PostgreSQLParserREPLICA, PostgreSQLParserRESET, PostgreSQLParserRESTART, PostgreSQLParserRESTRICT, PostgreSQLParserRETURNS, PostgreSQLParserREVOKE, PostgreSQLParserROLE, PostgreSQLParserROLLBACK, PostgreSQLParserROWS, PostgreSQLParserRULE, PostgreSQLParserSAVEPOINT, PostgreSQLParserSCHEMA, PostgreSQLParserSCROLL, PostgreSQLParserSEARCH, PostgreSQLParserSECOND_P, PostgreSQLParserSECURITY, PostgreSQLParserSEQUENCE, PostgreSQLParserSEQUENCES, PostgreSQLParserSERIALIZABLE, PostgreSQLParserSERVER, PostgreSQLParserSESSION, PostgreSQLParserSET, PostgreSQLParserSHARE, PostgreSQLParserSHOW, PostgreSQLParserSIMPLE, PostgreSQLParserSNAPSHOT, PostgreSQLParserSTABLE, PostgreSQLParserSTANDALONE_P, PostgreSQLParserSTART, PostgreSQLParserSTATEMENT, PostgreSQLParserSTATISTICS, PostgreSQLParserSTDIN, PostgreSQLParserSTDOUT, PostgreSQLParserSTORAGE, PostgreSQLParserSTRICT_P, PostgreSQLParserSTRIP_P, PostgreSQLParserSYSID, PostgreSQLParserSYSTEM_P, PostgreSQLParserTABLES, PostgreSQLParserTABLESPACE, PostgreSQLParserTEMP, PostgreSQLParserTEMPLATE, PostgreSQLParserTEMPORARY, PostgreSQLParserTEXT_P, PostgreSQLParserTRANSACTION, PostgreSQLParserTRIGGER, PostgreSQLParserTRUNCATE, PostgreSQLParserTRUSTED, PostgreSQLParserTYPE_P, PostgreSQLParserTYPES_P, PostgreSQLParserUNBOUNDED, PostgreSQLParserUNCOMMITTED, PostgreSQLParserUNENCRYPTED, PostgreSQLParserUNKNOWN, PostgreSQLParserUNLISTEN, PostgreSQLParserUNLOGGED, PostgreSQLParserUNTIL, PostgreSQLParserUPDATE, PostgreSQLParserVACUUM, PostgreSQLParserVALID, PostgreSQLParserVALIDATE, PostgreSQLParserVALIDATOR, PostgreSQLParserVARYING, PostgreSQLParserVERSION_P, PostgreSQLParserVIEW, PostgreSQLParserVOLATILE, PostgreSQLParserWHITESPACE_P, PostgreSQLParserWITHOUT, PostgreSQLParserWORK, PostgreSQLParserWRAPPER, PostgreSQLParserWRITE, PostgreSQLParserXML_P, PostgreSQLParserYEAR_P, PostgreSQLParserYES_P, PostgreSQLParserZONE, PostgreSQLParserBETWEEN, PostgreSQLParserBIGINT, PostgreSQLParserBIT, PostgreSQLParserBOOLEAN_P, PostgreSQLParserCHAR_P, PostgreSQLParserCHARACTER, PostgreSQLParserCOALESCE, PostgreSQLParserDEC, PostgreSQLParserDECIMAL_P, PostgreSQLParserEXISTS, PostgreSQLParserEXTRACT, PostgreSQLParserFLOAT_P, PostgreSQLParserGREATEST, PostgreSQLParserINOUT, PostgreSQLParserINT_P, PostgreSQLParserINTEGER, PostgreSQLParserINTERVAL, PostgreSQLParserLEAST, PostgreSQLParserNATIONAL, PostgreSQLParserNCHAR, PostgreSQLParserNONE, PostgreSQLParserNULLIF, PostgreSQLParserNUMERIC, PostgreSQLParserOVERLAY, PostgreSQLParserPOSITION, PostgreSQLParserPRECISION, PostgreSQLParserREAL, PostgreSQLParserROW, PostgreSQLParserSETOF, PostgreSQLParserSMALLINT, PostgreSQLParserSUBSTRING, PostgreSQLParserTIME, PostgreSQLParserTIMESTAMP, PostgreSQLParserTREAT, PostgreSQLParserTRIM, PostgreSQLParserVALUES, PostgreSQLParserVARCHAR, PostgreSQLParserXMLATTRIBUTES, PostgreSQLParserXMLCOMMENT, PostgreSQLParserXMLAGG, PostgreSQLParserXML_IS_WELL_FORMED, PostgreSQLParserXML_IS_WELL_FORMED_DOCUMENT, PostgreSQLParserXML_IS_WELL_FORMED_CONTENT, PostgreSQLParserXPATH, PostgreSQLParserXPATH_EXISTS, PostgreSQLParserXMLCONCAT, PostgreSQLParserXMLELEMENT, PostgreSQLParserXMLEXISTS, PostgreSQLParserXMLFOREST, PostgreSQLParserXMLPARSE, PostgreSQLParserXMLPI, PostgreSQLParserXMLROOT, PostgreSQLParserXMLSERIALIZE, PostgreSQLParserCALL, PostgreSQLParserCURRENT_P, PostgreSQLParserATTACH, PostgreSQLParserDETACH, PostgreSQLParserEXPRESSION, PostgreSQLParserGENERATED, PostgreSQLParserLOGGED, PostgreSQLParserSTORED, PostgreSQLParserINCLUDE, PostgreSQLParserROUTINE, PostgreSQLParserTRANSFORM, PostgreSQLParserIMPORT_P, PostgreSQLParserPOLICY, PostgreSQLParserMETHOD, PostgreSQLParserREFERENCING, PostgreSQLParserNEW, PostgreSQLParserOLD, PostgreSQLParserVALUE_P, PostgreSQLParserSUBSCRIPTION, PostgreSQLParserPUBLICATION, PostgreSQLParserOUT_P, PostgreSQLParserROUTINES, PostgreSQLParserSCHEMAS, PostgreSQLParserPROCEDURES, PostgreSQLParserINPUT_P, PostgreSQLParserSUPPORT, PostgreSQLParserPARALLEL, PostgreSQLParserSQL_P, PostgreSQLParserDEPENDS, PostgreSQLParserOVERRIDING, PostgreSQLParserCONFLICT, PostgreSQLParserSKIP_P, PostgreSQLParserLOCKED, PostgreSQLParserTIES, PostgreSQLParserROLLUP, PostgreSQLParserCUBE, PostgreSQLParserGROUPING, PostgreSQLParserSETS, PostgreSQLParserTABLESAMPLE, PostgreSQLParserORDINALITY, PostgreSQLParserXMLTABLE, PostgreSQLParserCOLUMNS, PostgreSQLParserXMLNAMESPACES, PostgreSQLParserROWTYPE, PostgreSQLParserNORMALIZED, PostgreSQLParserWITHIN, PostgreSQLParserFILTER, PostgreSQLParserGROUPS, PostgreSQLParserOTHERS, PostgreSQLParserNFC, PostgreSQLParserNFD, PostgreSQLParserNFKC, PostgreSQLParserNFKD, PostgreSQLParserUESCAPE, PostgreSQLParserVIEWS, PostgreSQLParserNORMALIZE, PostgreSQLParserDUMP, PostgreSQLParserPRINT_STRICT_PARAMS, PostgreSQLParserVARIABLE_CONFLICT, PostgreSQLParserERROR, PostgreSQLParserUSE_VARIABLE, PostgreSQLParserUSE_COLUMN, PostgreSQLParserALIAS, PostgreSQLParserCONSTANT, PostgreSQLParserPERFORM, PostgreSQLParserGET, PostgreSQLParserDIAGNOSTICS, PostgreSQLParserSTACKED, PostgreSQLParserELSIF, PostgreSQLParserREVERSE, PostgreSQLParserSLICE, PostgreSQLParserEXIT, PostgreSQLParserRETURN, PostgreSQLParserQUERY, PostgreSQLParserRAISE, PostgreSQLParserSQLSTATE, PostgreSQLParserDEBUG, PostgreSQLParserLOG, PostgreSQLParserINFO, PostgreSQLParserNOTICE, PostgreSQLParserWARNING, PostgreSQLParserEXCEPTION, PostgreSQLParserASSERT, PostgreSQLParserOPEN, PostgreSQLParserABS, PostgreSQLParserCBRT, PostgreSQLParserCEIL, PostgreSQLParserCEILING, PostgreSQLParserDEGREES, PostgreSQLParserDIV, PostgreSQLParserEXP, PostgreSQLParserFACTORIAL, PostgreSQLParserFLOOR, PostgreSQLParserGCD, PostgreSQLParserLCM, PostgreSQLParserLN, PostgreSQLParserLOG10, PostgreSQLParserMIN_SCALE, PostgreSQLParserMOD, PostgreSQLParserPI, PostgreSQLParserPOWER, PostgreSQLParserRADIANS, PostgreSQLParserROUND, PostgreSQLParserSCALE, PostgreSQLParserSIGN, PostgreSQLParserSQRT, PostgreSQLParserTRIM_SCALE, PostgreSQLParserTRUNC, PostgreSQLParserWIDTH_BUCKET, PostgreSQLParserRANDOM, PostgreSQLParserSETSEED, PostgreSQLParserACOS, PostgreSQLParserACOSD, PostgreSQLParserASIN, PostgreSQLParserASIND, PostgreSQLParserATAN, PostgreSQLParserATAND, PostgreSQLParserATAN2, PostgreSQLParserATAN2D, PostgreSQLParserCOS, PostgreSQLParserCOSD, PostgreSQLParserCOT, PostgreSQLParserCOTD, PostgreSQLParserSIN, PostgreSQLParserSIND, PostgreSQLParserTAN, PostgreSQLParserTAND, PostgreSQLParserSINH, PostgreSQLParserCOSH, PostgreSQLParserTANH, PostgreSQLParserASINH, PostgreSQLParserACOSH, PostgreSQLParserATANH, PostgreSQLParserBIT_LENGTH, PostgreSQLParserCHAR_LENGTH, PostgreSQLParserCHARACTER_LENGTH, PostgreSQLParserLOWER, PostgreSQLParserOCTET_LENGTH, PostgreSQLParserUPPER, PostgreSQLParserASCII, PostgreSQLParserBTRIM, PostgreSQLParserCHR, PostgreSQLParserCONCAT, PostgreSQLParserCONCAT_WS, PostgreSQLParserFORMAT, PostgreSQLParserINITCAP, PostgreSQLParserLENGTH, PostgreSQLParserLPAD, PostgreSQLParserLTRIM, PostgreSQLParserMD5, PostgreSQLParserPARSE_IDENT, PostgreSQLParserPG_CLIENT_ENCODING, PostgreSQLParserQUOTE_IDENT, PostgreSQLParserQUOTE_LITERAL, PostgreSQLParserQUOTE_NULLABLE, PostgreSQLParserREGEXP_COUNT, PostgreSQLParserREGEXP_INSTR, PostgreSQLParserREGEXP_LIKE, PostgreSQLParserREGEXP_MATCH, PostgreSQLParserREGEXP_MATCHES, PostgreSQLParserREGEXP_REPLACE, PostgreSQLParserREGEXP_SPLIT_TO_ARRAY, PostgreSQLParserREGEXP_SPLIT_TO_TABLE, PostgreSQLParserREGEXP_SUBSTR, PostgreSQLParserREPEAT, PostgreSQLParserRPAD, PostgreSQLParserRTRIM, PostgreSQLParserSPLIT_PART, PostgreSQLParserSTARTS_WITH, PostgreSQLParserSTRING_TO_ARRAY, PostgreSQLParserSTRING_TO_TABLE, PostgreSQLParserSTRPOS, PostgreSQLParserSUBSTR, PostgreSQLParserTO_ASCII, PostgreSQLParserTO_HEX, PostgreSQLParserTRANSLATE, PostgreSQLParserUNISTR, PostgreSQLParserAGE, PostgreSQLParserCLOCK_TIMESTAMP, PostgreSQLParserDATE_BIN, PostgreSQLParserDATE_PART, PostgreSQLParserDATE_TRUNC, PostgreSQLParserISFINITE, PostgreSQLParserJUSTIFY_DAYS, PostgreSQLParserJUSTIFY_HOURS, PostgreSQLParserJUSTIFY_INTERVAL, PostgreSQLParserMAKE_DATE, PostgreSQLParserMAKE_INTERVAL, PostgreSQLParserMAKE_TIME, PostgreSQLParserMAKE_TIMESTAMP, PostgreSQLParserMAKE_TIMESTAMPTZ, PostgreSQLParserNOW, PostgreSQLParserSTATEMENT_TIMESTAMP, PostgreSQLParserTIMEOFDAY, PostgreSQLParserTRANSACTION_TIMESTAMP, PostgreSQLParserTO_TIMESTAMP, PostgreSQLParserTO_CHAR, PostgreSQLParserTO_DATE, PostgreSQLParserTO_NUMBER, PostgreSQLParserIdentifier, PostgreSQLParserQuotedIdentifier, PostgreSQLParserUnicodeQuotedIdentifier, PostgreSQLParserStringConstant, PostgreSQLParserUnicodeEscapeStringConstant, PostgreSQLParserBeginDollarStringConstant, PostgreSQLParserBinaryStringConstant, PostgreSQLParserHexadecimalStringConstant, PostgreSQLParserIntegral, PostgreSQLParserNumeric, PostgreSQLParserPLSQLVARIABLENAME, PostgreSQLParserPLSQLIDENTIFIER, PostgreSQLParserEscapeStringConstant:
		localctx = NewTarget_labelContext(p, localctx)
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(9715)
			p.A_expr()
		}
		p.SetState(9720)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}

		switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 643, p.GetParserRuleContext()) {
		case 1:
			{
				p.SetState(9716)
				p.Match(PostgreSQLParserAS)
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}
			{
				p.SetState(9717)
				p.Collabel()
			}

		case 2:
			{
				p.SetState(9718)
				p.Identifier()
			}

		case 3:

		case antlr.ATNInvalidAltNumber:
			goto errorExit
		}

	case PostgreSQLParserSTAR:
		localctx = NewTarget_starContext(p, localctx)
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(9722)
			p.Match(PostgreSQLParserSTAR)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	default:
		p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IQualified_name_listContext is an interface to support dynamic dispatch.
type IQualified_name_listContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	AllQualified_name() []IQualified_nameContext
	Qualified_name(i int) IQualified_nameContext
	AllCOMMA() []antlr.TerminalNode
	COMMA(i int) antlr.TerminalNode

	// IsQualified_name_listContext differentiates from other interfaces.
	IsQualified_name_listContext()
}

type Qualified_name_listContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyQualified_name_listContext() *Qualified_name_listContext {
	var p = new(Qualified_name_listContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_qualified_name_list
	return p
}

func InitEmptyQualified_name_listContext(p *Qualified_name_listContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_qualified_name_list
}

func (*Qualified_name_listContext) IsQualified_name_listContext() {}

func NewQualified_name_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Qualified_name_listContext {
	var p = new(Qualified_name_listContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_qualified_name_list

	return p
}

func (s *Qualified_name_listContext) GetParser() antlr.Parser { return s.parser }

func (s *Qualified_name_listContext) AllQualified_name() []IQualified_nameContext {
	children := s.GetChildren()
	len := 0
	for _, ctx := range children {
		if _, ok := ctx.(IQualified_nameContext); ok {
			len++
		}
	}

	tst := make([]IQualified_nameContext, len)
	i := 0
	for _, ctx := range children {
		if t, ok := ctx.(IQualified_nameContext); ok {
			tst[i] = t.(IQualified_nameContext)
			i++
		}
	}

	return tst
}

func (s *Qualified_name_listContext) Qualified_name(i int) IQualified_nameContext {
	var t antlr.RuleContext
	j := 0
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IQualified_nameContext); ok {
			if j == i {
				t = ctx.(antlr.RuleContext)
				break
			}
			j++
		}
	}

	if t == nil {
		return nil
	}

	return t.(IQualified_nameContext)
}

func (s *Qualified_name_listContext) AllCOMMA() []antlr.TerminalNode {
	return s.GetTokens(PostgreSQLParserCOMMA)
}

func (s *Qualified_name_listContext) COMMA(i int) antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCOMMA, i)
}

func (s *Qualified_name_listContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Qualified_name_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Qualified_name_listContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterQualified_name_list(s)
	}
}

func (s *Qualified_name_listContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitQualified_name_list(s)
	}
}

func (s *Qualified_name_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitQualified_name_list(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Qualified_name_list() (localctx IQualified_name_listContext) {
	localctx = NewQualified_name_listContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1334, PostgreSQLParserRULE_qualified_name_list)
	var _la int

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(9725)
		p.Qualified_name()
	}
	p.SetState(9730)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}
	_la = p.GetTokenStream().LA(1)

	for _la == PostgreSQLParserCOMMA {
		{
			p.SetState(9726)
			p.Match(PostgreSQLParserCOMMA)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(9727)
			p.Qualified_name()
		}

		p.SetState(9732)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}
		_la = p.GetTokenStream().LA(1)
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IQualified_nameContext is an interface to support dynamic dispatch.
type IQualified_nameContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Colid() IColidContext
	Indirection() IIndirectionContext

	// IsQualified_nameContext differentiates from other interfaces.
	IsQualified_nameContext()
}

type Qualified_nameContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyQualified_nameContext() *Qualified_nameContext {
	var p = new(Qualified_nameContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_qualified_name
	return p
}

func InitEmptyQualified_nameContext(p *Qualified_nameContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_qualified_name
}

func (*Qualified_nameContext) IsQualified_nameContext() {}

func NewQualified_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Qualified_nameContext {
	var p = new(Qualified_nameContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_qualified_name

	return p
}

func (s *Qualified_nameContext) GetParser() antlr.Parser { return s.parser }

func (s *Qualified_nameContext) Colid() IColidContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IColidContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IColidContext)
}

func (s *Qualified_nameContext) Indirection() IIndirectionContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IIndirectionContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IIndirectionContext)
}

func (s *Qualified_nameContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Qualified_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Qualified_nameContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterQualified_name(s)
	}
}

func (s *Qualified_nameContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitQualified_name(s)
	}
}

func (s *Qualified_nameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitQualified_name(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Qualified_name() (localctx IQualified_nameContext) {
	localctx = NewQualified_nameContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1336, PostgreSQLParserRULE_qualified_name)
	var _la int

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(9733)
		p.Colid()
	}
	p.SetState(9735)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}
	_la = p.GetTokenStream().LA(1)

	if _la == PostgreSQLParserOPEN_BRACKET || _la == PostgreSQLParserDOT {
		{
			p.SetState(9734)
			p.Indirection()
		}

	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IName_listContext is an interface to support dynamic dispatch.
type IName_listContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	AllName() []INameContext
	Name(i int) INameContext
	AllCOMMA() []antlr.TerminalNode
	COMMA(i int) antlr.TerminalNode

	// IsName_listContext differentiates from other interfaces.
	IsName_listContext()
}

type Name_listContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyName_listContext() *Name_listContext {
	var p = new(Name_listContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_name_list
	return p
}

func InitEmptyName_listContext(p *Name_listContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_name_list
}

func (*Name_listContext) IsName_listContext() {}

func NewName_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Name_listContext {
	var p = new(Name_listContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_name_list

	return p
}

func (s *Name_listContext) GetParser() antlr.Parser { return s.parser }

func (s *Name_listContext) AllName() []INameContext {
	children := s.GetChildren()
	len := 0
	for _, ctx := range children {
		if _, ok := ctx.(INameContext); ok {
			len++
		}
	}

	tst := make([]INameContext, len)
	i := 0
	for _, ctx := range children {
		if t, ok := ctx.(INameContext); ok {
			tst[i] = t.(INameContext)
			i++
		}
	}

	return tst
}

func (s *Name_listContext) Name(i int) INameContext {
	var t antlr.RuleContext
	j := 0
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(INameContext); ok {
			if j == i {
				t = ctx.(antlr.RuleContext)
				break
			}
			j++
		}
	}

	if t == nil {
		return nil
	}

	return t.(INameContext)
}

func (s *Name_listContext) AllCOMMA() []antlr.TerminalNode {
	return s.GetTokens(PostgreSQLParserCOMMA)
}

func (s *Name_listContext) COMMA(i int) antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCOMMA, i)
}

func (s *Name_listContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Name_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Name_listContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterName_list(s)
	}
}

func (s *Name_listContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitName_list(s)
	}
}

func (s *Name_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitName_list(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Name_list() (localctx IName_listContext) {
	localctx = NewName_listContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1338, PostgreSQLParserRULE_name_list)
	var _la int

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(9737)
		p.Name()
	}
	p.SetState(9742)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}
	_la = p.GetTokenStream().LA(1)

	for _la == PostgreSQLParserCOMMA {
		{
			p.SetState(9738)
			p.Match(PostgreSQLParserCOMMA)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(9739)
			p.Name()
		}

		p.SetState(9744)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}
		_la = p.GetTokenStream().LA(1)
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// INameContext is an interface to support dynamic dispatch.
type INameContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Colid() IColidContext

	// IsNameContext differentiates from other interfaces.
	IsNameContext()
}

type NameContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyNameContext() *NameContext {
	var p = new(NameContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_name
	return p
}

func InitEmptyNameContext(p *NameContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_name
}

func (*NameContext) IsNameContext() {}

func NewNameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *NameContext {
	var p = new(NameContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_name

	return p
}

func (s *NameContext) GetParser() antlr.Parser { return s.parser }

func (s *NameContext) Colid() IColidContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IColidContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IColidContext)
}

func (s *NameContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *NameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *NameContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterName(s)
	}
}

func (s *NameContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitName(s)
	}
}

func (s *NameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitName(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Name() (localctx INameContext) {
	localctx = NewNameContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1340, PostgreSQLParserRULE_name)
	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(9745)
		p.Colid()
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IAttr_nameContext is an interface to support dynamic dispatch.
type IAttr_nameContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Collabel() ICollabelContext

	// IsAttr_nameContext differentiates from other interfaces.
	IsAttr_nameContext()
}

type Attr_nameContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyAttr_nameContext() *Attr_nameContext {
	var p = new(Attr_nameContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_attr_name
	return p
}

func InitEmptyAttr_nameContext(p *Attr_nameContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_attr_name
}

func (*Attr_nameContext) IsAttr_nameContext() {}

func NewAttr_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Attr_nameContext {
	var p = new(Attr_nameContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_attr_name

	return p
}

func (s *Attr_nameContext) GetParser() antlr.Parser { return s.parser }

func (s *Attr_nameContext) Collabel() ICollabelContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ICollabelContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ICollabelContext)
}

func (s *Attr_nameContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Attr_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Attr_nameContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterAttr_name(s)
	}
}

func (s *Attr_nameContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitAttr_name(s)
	}
}

func (s *Attr_nameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitAttr_name(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Attr_name() (localctx IAttr_nameContext) {
	localctx = NewAttr_nameContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1342, PostgreSQLParserRULE_attr_name)
	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(9747)
		p.Collabel()
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IFile_nameContext is an interface to support dynamic dispatch.
type IFile_nameContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Sconst() ISconstContext

	// IsFile_nameContext differentiates from other interfaces.
	IsFile_nameContext()
}

type File_nameContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyFile_nameContext() *File_nameContext {
	var p = new(File_nameContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_file_name
	return p
}

func InitEmptyFile_nameContext(p *File_nameContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_file_name
}

func (*File_nameContext) IsFile_nameContext() {}

func NewFile_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *File_nameContext {
	var p = new(File_nameContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_file_name

	return p
}

func (s *File_nameContext) GetParser() antlr.Parser { return s.parser }

func (s *File_nameContext) Sconst() ISconstContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ISconstContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ISconstContext)
}

func (s *File_nameContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *File_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *File_nameContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterFile_name(s)
	}
}

func (s *File_nameContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitFile_name(s)
	}
}

func (s *File_nameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitFile_name(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) File_name() (localctx IFile_nameContext) {
	localctx = NewFile_nameContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1344, PostgreSQLParserRULE_file_name)
	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(9749)
		p.Sconst()
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IFunc_nameContext is an interface to support dynamic dispatch.
type IFunc_nameContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Builtin_function_name() IBuiltin_function_nameContext
	Type_function_name() IType_function_nameContext
	Colid() IColidContext
	Indirection() IIndirectionContext
	LEFT() antlr.TerminalNode
	RIGHT() antlr.TerminalNode

	// IsFunc_nameContext differentiates from other interfaces.
	IsFunc_nameContext()
}

type Func_nameContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyFunc_nameContext() *Func_nameContext {
	var p = new(Func_nameContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_func_name
	return p
}

func InitEmptyFunc_nameContext(p *Func_nameContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_func_name
}

func (*Func_nameContext) IsFunc_nameContext() {}

func NewFunc_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Func_nameContext {
	var p = new(Func_nameContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_func_name

	return p
}

func (s *Func_nameContext) GetParser() antlr.Parser { return s.parser }

func (s *Func_nameContext) Builtin_function_name() IBuiltin_function_nameContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IBuiltin_function_nameContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IBuiltin_function_nameContext)
}

func (s *Func_nameContext) Type_function_name() IType_function_nameContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IType_function_nameContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IType_function_nameContext)
}

func (s *Func_nameContext) Colid() IColidContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IColidContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IColidContext)
}

func (s *Func_nameContext) Indirection() IIndirectionContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IIndirectionContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IIndirectionContext)
}

func (s *Func_nameContext) LEFT() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserLEFT, 0)
}

func (s *Func_nameContext) RIGHT() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserRIGHT, 0)
}

func (s *Func_nameContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Func_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Func_nameContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterFunc_name(s)
	}
}

func (s *Func_nameContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitFunc_name(s)
	}
}

func (s *Func_nameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitFunc_name(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Func_name() (localctx IFunc_nameContext) {
	localctx = NewFunc_nameContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1346, PostgreSQLParserRULE_func_name)
	p.SetState(9758)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 648, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(9751)
			p.Builtin_function_name()
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(9752)
			p.Type_function_name()
		}

	case 3:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(9753)
			p.Colid()
		}
		{
			p.SetState(9754)
			p.Indirection()
		}

	case 4:
		p.EnterOuterAlt(localctx, 4)
		{
			p.SetState(9756)
			p.Match(PostgreSQLParserLEFT)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 5:
		p.EnterOuterAlt(localctx, 5)
		{
			p.SetState(9757)
			p.Match(PostgreSQLParserRIGHT)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case antlr.ATNInvalidAltNumber:
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IAexprconstContext is an interface to support dynamic dispatch.
type IAexprconstContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Iconst() IIconstContext
	Fconst() IFconstContext
	Sconst() ISconstContext
	Bconst() IBconstContext
	Xconst() IXconstContext
	Func_name() IFunc_nameContext
	OPEN_PAREN() antlr.TerminalNode
	Func_arg_list() IFunc_arg_listContext
	Opt_sort_clause() IOpt_sort_clauseContext
	CLOSE_PAREN() antlr.TerminalNode
	Consttypename() IConsttypenameContext
	Constinterval() IConstintervalContext
	Opt_interval() IOpt_intervalContext
	TRUE_P() antlr.TerminalNode
	FALSE_P() antlr.TerminalNode
	NULL_P() antlr.TerminalNode

	// IsAexprconstContext differentiates from other interfaces.
	IsAexprconstContext()
}

type AexprconstContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyAexprconstContext() *AexprconstContext {
	var p = new(AexprconstContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_aexprconst
	return p
}

func InitEmptyAexprconstContext(p *AexprconstContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_aexprconst
}

func (*AexprconstContext) IsAexprconstContext() {}

func NewAexprconstContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AexprconstContext {
	var p = new(AexprconstContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_aexprconst

	return p
}

func (s *AexprconstContext) GetParser() antlr.Parser { return s.parser }

func (s *AexprconstContext) Iconst() IIconstContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IIconstContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IIconstContext)
}

func (s *AexprconstContext) Fconst() IFconstContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IFconstContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IFconstContext)
}

func (s *AexprconstContext) Sconst() ISconstContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ISconstContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ISconstContext)
}

func (s *AexprconstContext) Bconst() IBconstContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IBconstContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IBconstContext)
}

func (s *AexprconstContext) Xconst() IXconstContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IXconstContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IXconstContext)
}

func (s *AexprconstContext) Func_name() IFunc_nameContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IFunc_nameContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IFunc_nameContext)
}

func (s *AexprconstContext) OPEN_PAREN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserOPEN_PAREN, 0)
}

func (s *AexprconstContext) Func_arg_list() IFunc_arg_listContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IFunc_arg_listContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IFunc_arg_listContext)
}

func (s *AexprconstContext) Opt_sort_clause() IOpt_sort_clauseContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOpt_sort_clauseContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOpt_sort_clauseContext)
}

func (s *AexprconstContext) CLOSE_PAREN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCLOSE_PAREN, 0)
}

func (s *AexprconstContext) Consttypename() IConsttypenameContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IConsttypenameContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IConsttypenameContext)
}

func (s *AexprconstContext) Constinterval() IConstintervalContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IConstintervalContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IConstintervalContext)
}

func (s *AexprconstContext) Opt_interval() IOpt_intervalContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOpt_intervalContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOpt_intervalContext)
}

func (s *AexprconstContext) TRUE_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserTRUE_P, 0)
}

func (s *AexprconstContext) FALSE_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserFALSE_P, 0)
}

func (s *AexprconstContext) NULL_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserNULL_P, 0)
}

func (s *AexprconstContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *AexprconstContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *AexprconstContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterAexprconst(s)
	}
}

func (s *AexprconstContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitAexprconst(s)
	}
}

func (s *AexprconstContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitAexprconst(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Aexprconst() (localctx IAexprconstContext) {
	localctx = NewAexprconstContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1348, PostgreSQLParserRULE_aexprconst)
	p.SetState(9792)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 651, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(9760)
			p.Iconst()
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(9761)
			p.Fconst()
		}

	case 3:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(9762)
			p.Sconst()
		}

	case 4:
		p.EnterOuterAlt(localctx, 4)
		{
			p.SetState(9763)
			p.Bconst()
		}

	case 5:
		p.EnterOuterAlt(localctx, 5)
		{
			p.SetState(9764)
			p.Xconst()
		}

	case 6:
		p.EnterOuterAlt(localctx, 6)
		{
			p.SetState(9765)
			p.Func_name()
		}
		p.SetState(9773)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}

		switch p.GetTokenStream().LA(1) {
		case PostgreSQLParserStringConstant, PostgreSQLParserUnicodeEscapeStringConstant, PostgreSQLParserBeginDollarStringConstant, PostgreSQLParserEscapeStringConstant:
			{
				p.SetState(9766)
				p.Sconst()
			}

		case PostgreSQLParserOPEN_PAREN:
			{
				p.SetState(9767)
				p.Match(PostgreSQLParserOPEN_PAREN)
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}
			{
				p.SetState(9768)
				p.Func_arg_list()
			}
			{
				p.SetState(9769)
				p.Opt_sort_clause()
			}
			{
				p.SetState(9770)
				p.Match(PostgreSQLParserCLOSE_PAREN)
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}
			{
				p.SetState(9771)
				p.Sconst()
			}

		default:
			p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
			goto errorExit
		}

	case 7:
		p.EnterOuterAlt(localctx, 7)
		{
			p.SetState(9775)
			p.Consttypename()
		}
		{
			p.SetState(9776)
			p.Sconst()
		}

	case 8:
		p.EnterOuterAlt(localctx, 8)
		{
			p.SetState(9778)
			p.Constinterval()
		}
		p.SetState(9787)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}

		switch p.GetTokenStream().LA(1) {
		case PostgreSQLParserStringConstant, PostgreSQLParserUnicodeEscapeStringConstant, PostgreSQLParserBeginDollarStringConstant, PostgreSQLParserEscapeStringConstant:
			{
				p.SetState(9779)
				p.Sconst()
			}
			{
				p.SetState(9780)
				p.Opt_interval()
			}

		case PostgreSQLParserOPEN_PAREN:
			{
				p.SetState(9782)
				p.Match(PostgreSQLParserOPEN_PAREN)
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}
			{
				p.SetState(9783)
				p.Iconst()
			}
			{
				p.SetState(9784)
				p.Match(PostgreSQLParserCLOSE_PAREN)
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}
			{
				p.SetState(9785)
				p.Sconst()
			}

		default:
			p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
			goto errorExit
		}

	case 9:
		p.EnterOuterAlt(localctx, 9)
		{
			p.SetState(9789)
			p.Match(PostgreSQLParserTRUE_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 10:
		p.EnterOuterAlt(localctx, 10)
		{
			p.SetState(9790)
			p.Match(PostgreSQLParserFALSE_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 11:
		p.EnterOuterAlt(localctx, 11)
		{
			p.SetState(9791)
			p.Match(PostgreSQLParserNULL_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case antlr.ATNInvalidAltNumber:
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IXconstContext is an interface to support dynamic dispatch.
type IXconstContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	HexadecimalStringConstant() antlr.TerminalNode

	// IsXconstContext differentiates from other interfaces.
	IsXconstContext()
}

type XconstContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyXconstContext() *XconstContext {
	var p = new(XconstContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_xconst
	return p
}

func InitEmptyXconstContext(p *XconstContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_xconst
}

func (*XconstContext) IsXconstContext() {}

func NewXconstContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *XconstContext {
	var p = new(XconstContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_xconst

	return p
}

func (s *XconstContext) GetParser() antlr.Parser { return s.parser }

func (s *XconstContext) HexadecimalStringConstant() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserHexadecimalStringConstant, 0)
}

func (s *XconstContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *XconstContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *XconstContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterXconst(s)
	}
}

func (s *XconstContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitXconst(s)
	}
}

func (s *XconstContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitXconst(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Xconst() (localctx IXconstContext) {
	localctx = NewXconstContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1350, PostgreSQLParserRULE_xconst)
	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(9794)
		p.Match(PostgreSQLParserHexadecimalStringConstant)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IBconstContext is an interface to support dynamic dispatch.
type IBconstContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	BinaryStringConstant() antlr.TerminalNode

	// IsBconstContext differentiates from other interfaces.
	IsBconstContext()
}

type BconstContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyBconstContext() *BconstContext {
	var p = new(BconstContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_bconst
	return p
}

func InitEmptyBconstContext(p *BconstContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_bconst
}

func (*BconstContext) IsBconstContext() {}

func NewBconstContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *BconstContext {
	var p = new(BconstContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_bconst

	return p
}

func (s *BconstContext) GetParser() antlr.Parser { return s.parser }

func (s *BconstContext) BinaryStringConstant() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserBinaryStringConstant, 0)
}

func (s *BconstContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *BconstContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *BconstContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterBconst(s)
	}
}

func (s *BconstContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitBconst(s)
	}
}

func (s *BconstContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitBconst(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Bconst() (localctx IBconstContext) {
	localctx = NewBconstContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1352, PostgreSQLParserRULE_bconst)
	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(9796)
		p.Match(PostgreSQLParserBinaryStringConstant)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IFconstContext is an interface to support dynamic dispatch.
type IFconstContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Numeric() antlr.TerminalNode

	// IsFconstContext differentiates from other interfaces.
	IsFconstContext()
}

type FconstContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyFconstContext() *FconstContext {
	var p = new(FconstContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_fconst
	return p
}

func InitEmptyFconstContext(p *FconstContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_fconst
}

func (*FconstContext) IsFconstContext() {}

func NewFconstContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *FconstContext {
	var p = new(FconstContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_fconst

	return p
}

func (s *FconstContext) GetParser() antlr.Parser { return s.parser }

func (s *FconstContext) Numeric() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserNumeric, 0)
}

func (s *FconstContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *FconstContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *FconstContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterFconst(s)
	}
}

func (s *FconstContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitFconst(s)
	}
}

func (s *FconstContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitFconst(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Fconst() (localctx IFconstContext) {
	localctx = NewFconstContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1354, PostgreSQLParserRULE_fconst)
	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(9798)
		p.Match(PostgreSQLParserNumeric)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IIconstContext is an interface to support dynamic dispatch.
type IIconstContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Integral() antlr.TerminalNode

	// IsIconstContext differentiates from other interfaces.
	IsIconstContext()
}

type IconstContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyIconstContext() *IconstContext {
	var p = new(IconstContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_iconst
	return p
}

func InitEmptyIconstContext(p *IconstContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_iconst
}

func (*IconstContext) IsIconstContext() {}

func NewIconstContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *IconstContext {
	var p = new(IconstContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_iconst

	return p
}

func (s *IconstContext) GetParser() antlr.Parser { return s.parser }

func (s *IconstContext) Integral() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserIntegral, 0)
}

func (s *IconstContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *IconstContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *IconstContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterIconst(s)
	}
}

func (s *IconstContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitIconst(s)
	}
}

func (s *IconstContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitIconst(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Iconst() (localctx IIconstContext) {
	localctx = NewIconstContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1356, PostgreSQLParserRULE_iconst)
	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(9800)
		p.Match(PostgreSQLParserIntegral)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// ISconstContext is an interface to support dynamic dispatch.
type ISconstContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Anysconst() IAnysconstContext
	Opt_uescape() IOpt_uescapeContext

	// IsSconstContext differentiates from other interfaces.
	IsSconstContext()
}

type SconstContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptySconstContext() *SconstContext {
	var p = new(SconstContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_sconst
	return p
}

func InitEmptySconstContext(p *SconstContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_sconst
}

func (*SconstContext) IsSconstContext() {}

func NewSconstContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SconstContext {
	var p = new(SconstContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_sconst

	return p
}

func (s *SconstContext) GetParser() antlr.Parser { return s.parser }

func (s *SconstContext) Anysconst() IAnysconstContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IAnysconstContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IAnysconstContext)
}

func (s *SconstContext) Opt_uescape() IOpt_uescapeContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOpt_uescapeContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOpt_uescapeContext)
}

func (s *SconstContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *SconstContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *SconstContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterSconst(s)
	}
}

func (s *SconstContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitSconst(s)
	}
}

func (s *SconstContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitSconst(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Sconst() (localctx ISconstContext) {
	localctx = NewSconstContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1358, PostgreSQLParserRULE_sconst)
	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(9802)
		p.Anysconst()
	}
	{
		p.SetState(9803)
		p.Opt_uescape()
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IAnysconstContext is an interface to support dynamic dispatch.
type IAnysconstContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	StringConstant() antlr.TerminalNode
	UnicodeEscapeStringConstant() antlr.TerminalNode
	BeginDollarStringConstant() antlr.TerminalNode
	EndDollarStringConstant() antlr.TerminalNode
	AllDollarText() []antlr.TerminalNode
	DollarText(i int) antlr.TerminalNode
	EscapeStringConstant() antlr.TerminalNode

	// IsAnysconstContext differentiates from other interfaces.
	IsAnysconstContext()
}

type AnysconstContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyAnysconstContext() *AnysconstContext {
	var p = new(AnysconstContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_anysconst
	return p
}

func InitEmptyAnysconstContext(p *AnysconstContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_anysconst
}

func (*AnysconstContext) IsAnysconstContext() {}

func NewAnysconstContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AnysconstContext {
	var p = new(AnysconstContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_anysconst

	return p
}

func (s *AnysconstContext) GetParser() antlr.Parser { return s.parser }

func (s *AnysconstContext) StringConstant() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserStringConstant, 0)
}

func (s *AnysconstContext) UnicodeEscapeStringConstant() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserUnicodeEscapeStringConstant, 0)
}

func (s *AnysconstContext) BeginDollarStringConstant() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserBeginDollarStringConstant, 0)
}

func (s *AnysconstContext) EndDollarStringConstant() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserEndDollarStringConstant, 0)
}

func (s *AnysconstContext) AllDollarText() []antlr.TerminalNode {
	return s.GetTokens(PostgreSQLParserDollarText)
}

func (s *AnysconstContext) DollarText(i int) antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserDollarText, i)
}

func (s *AnysconstContext) EscapeStringConstant() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserEscapeStringConstant, 0)
}

func (s *AnysconstContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *AnysconstContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *AnysconstContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterAnysconst(s)
	}
}

func (s *AnysconstContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitAnysconst(s)
	}
}

func (s *AnysconstContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitAnysconst(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Anysconst() (localctx IAnysconstContext) {
	localctx = NewAnysconstContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1360, PostgreSQLParserRULE_anysconst)
	var _la int

	p.SetState(9816)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetTokenStream().LA(1) {
	case PostgreSQLParserStringConstant:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(9805)
			p.Match(PostgreSQLParserStringConstant)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case PostgreSQLParserUnicodeEscapeStringConstant:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(9806)
			p.Match(PostgreSQLParserUnicodeEscapeStringConstant)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case PostgreSQLParserBeginDollarStringConstant:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(9807)
			p.Match(PostgreSQLParserBeginDollarStringConstant)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		p.SetState(9811)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}
		_la = p.GetTokenStream().LA(1)

		for _la == PostgreSQLParserDollarText {
			{
				p.SetState(9808)
				p.Match(PostgreSQLParserDollarText)
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}

			p.SetState(9813)
			p.GetErrorHandler().Sync(p)
			if p.HasError() {
				goto errorExit
			}
			_la = p.GetTokenStream().LA(1)
		}
		{
			p.SetState(9814)
			p.Match(PostgreSQLParserEndDollarStringConstant)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case PostgreSQLParserEscapeStringConstant:
		p.EnterOuterAlt(localctx, 4)
		{
			p.SetState(9815)
			p.Match(PostgreSQLParserEscapeStringConstant)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	default:
		p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IOpt_uescapeContext is an interface to support dynamic dispatch.
type IOpt_uescapeContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	UESCAPE() antlr.TerminalNode
	Anysconst() IAnysconstContext

	// IsOpt_uescapeContext differentiates from other interfaces.
	IsOpt_uescapeContext()
}

type Opt_uescapeContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyOpt_uescapeContext() *Opt_uescapeContext {
	var p = new(Opt_uescapeContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opt_uescape
	return p
}

func InitEmptyOpt_uescapeContext(p *Opt_uescapeContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opt_uescape
}

func (*Opt_uescapeContext) IsOpt_uescapeContext() {}

func NewOpt_uescapeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_uescapeContext {
	var p = new(Opt_uescapeContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_opt_uescape

	return p
}

func (s *Opt_uescapeContext) GetParser() antlr.Parser { return s.parser }

func (s *Opt_uescapeContext) UESCAPE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserUESCAPE, 0)
}

func (s *Opt_uescapeContext) Anysconst() IAnysconstContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IAnysconstContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IAnysconstContext)
}

func (s *Opt_uescapeContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Opt_uescapeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Opt_uescapeContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterOpt_uescape(s)
	}
}

func (s *Opt_uescapeContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitOpt_uescape(s)
	}
}

func (s *Opt_uescapeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitOpt_uescape(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Opt_uescape() (localctx IOpt_uescapeContext) {
	localctx = NewOpt_uescapeContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1362, PostgreSQLParserRULE_opt_uescape)
	p.SetState(9821)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 654, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(9818)
			p.Match(PostgreSQLParserUESCAPE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(9819)
			p.Anysconst()
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)

	case antlr.ATNInvalidAltNumber:
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// ISignediconstContext is an interface to support dynamic dispatch.
type ISignediconstContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Iconst() IIconstContext
	PLUS() antlr.TerminalNode
	MINUS() antlr.TerminalNode

	// IsSignediconstContext differentiates from other interfaces.
	IsSignediconstContext()
}

type SignediconstContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptySignediconstContext() *SignediconstContext {
	var p = new(SignediconstContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_signediconst
	return p
}

func InitEmptySignediconstContext(p *SignediconstContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_signediconst
}

func (*SignediconstContext) IsSignediconstContext() {}

func NewSignediconstContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SignediconstContext {
	var p = new(SignediconstContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_signediconst

	return p
}

func (s *SignediconstContext) GetParser() antlr.Parser { return s.parser }

func (s *SignediconstContext) Iconst() IIconstContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IIconstContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IIconstContext)
}

func (s *SignediconstContext) PLUS() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserPLUS, 0)
}

func (s *SignediconstContext) MINUS() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserMINUS, 0)
}

func (s *SignediconstContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *SignediconstContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *SignediconstContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterSignediconst(s)
	}
}

func (s *SignediconstContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitSignediconst(s)
	}
}

func (s *SignediconstContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitSignediconst(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Signediconst() (localctx ISignediconstContext) {
	localctx = NewSignediconstContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1364, PostgreSQLParserRULE_signediconst)
	p.SetState(9828)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetTokenStream().LA(1) {
	case PostgreSQLParserIntegral:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(9823)
			p.Iconst()
		}

	case PostgreSQLParserPLUS:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(9824)
			p.Match(PostgreSQLParserPLUS)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(9825)
			p.Iconst()
		}

	case PostgreSQLParserMINUS:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(9826)
			p.Match(PostgreSQLParserMINUS)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(9827)
			p.Iconst()
		}

	default:
		p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IRoleidContext is an interface to support dynamic dispatch.
type IRoleidContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Rolespec() IRolespecContext

	// IsRoleidContext differentiates from other interfaces.
	IsRoleidContext()
}

type RoleidContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyRoleidContext() *RoleidContext {
	var p = new(RoleidContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_roleid
	return p
}

func InitEmptyRoleidContext(p *RoleidContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_roleid
}

func (*RoleidContext) IsRoleidContext() {}

func NewRoleidContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *RoleidContext {
	var p = new(RoleidContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_roleid

	return p
}

func (s *RoleidContext) GetParser() antlr.Parser { return s.parser }

func (s *RoleidContext) Rolespec() IRolespecContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IRolespecContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IRolespecContext)
}

func (s *RoleidContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *RoleidContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *RoleidContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterRoleid(s)
	}
}

func (s *RoleidContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitRoleid(s)
	}
}

func (s *RoleidContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitRoleid(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Roleid() (localctx IRoleidContext) {
	localctx = NewRoleidContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1366, PostgreSQLParserRULE_roleid)
	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(9830)
		p.Rolespec()
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IRolespecContext is an interface to support dynamic dispatch.
type IRolespecContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Nonreservedword() INonreservedwordContext
	CURRENT_USER() antlr.TerminalNode
	SESSION_USER() antlr.TerminalNode

	// IsRolespecContext differentiates from other interfaces.
	IsRolespecContext()
}

type RolespecContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyRolespecContext() *RolespecContext {
	var p = new(RolespecContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_rolespec
	return p
}

func InitEmptyRolespecContext(p *RolespecContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_rolespec
}

func (*RolespecContext) IsRolespecContext() {}

func NewRolespecContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *RolespecContext {
	var p = new(RolespecContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_rolespec

	return p
}

func (s *RolespecContext) GetParser() antlr.Parser { return s.parser }

func (s *RolespecContext) Nonreservedword() INonreservedwordContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(INonreservedwordContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(INonreservedwordContext)
}

func (s *RolespecContext) CURRENT_USER() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCURRENT_USER, 0)
}

func (s *RolespecContext) SESSION_USER() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserSESSION_USER, 0)
}

func (s *RolespecContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *RolespecContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *RolespecContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterRolespec(s)
	}
}

func (s *RolespecContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitRolespec(s)
	}
}

func (s *RolespecContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitRolespec(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Rolespec() (localctx IRolespecContext) {
	localctx = NewRolespecContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1368, PostgreSQLParserRULE_rolespec)
	p.SetState(9835)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetTokenStream().LA(1) {
	case PostgreSQLParserAND, PostgreSQLParserARRAY, PostgreSQLParserCOLLATE, PostgreSQLParserCOLUMN, PostgreSQLParserCONSTRAINT, PostgreSQLParserDEFAULT, PostgreSQLParserDO, PostgreSQLParserFETCH, PostgreSQLParserTABLE, PostgreSQLParserAUTHORIZATION, PostgreSQLParserBINARY, PostgreSQLParserCOLLATION, PostgreSQLParserCONCURRENTLY, PostgreSQLParserCROSS, PostgreSQLParserCURRENT_SCHEMA, PostgreSQLParserFREEZE, PostgreSQLParserFULL, PostgreSQLParserILIKE, PostgreSQLParserINNER_P, PostgreSQLParserIS, PostgreSQLParserISNULL, PostgreSQLParserJOIN, PostgreSQLParserLIKE, PostgreSQLParserNATURAL, PostgreSQLParserNOTNULL, PostgreSQLParserOUTER_P, PostgreSQLParserOVER, PostgreSQLParserOVERLAPS, PostgreSQLParserSIMILAR, PostgreSQLParserVERBOSE, PostgreSQLParserABORT_P, PostgreSQLParserABSOLUTE_P, PostgreSQLParserACCESS, PostgreSQLParserACTION, PostgreSQLParserADD_P, PostgreSQLParserADMIN, PostgreSQLParserAFTER, PostgreSQLParserAGGREGATE, PostgreSQLParserALSO, PostgreSQLParserALTER, PostgreSQLParserALWAYS, PostgreSQLParserASSERTION, PostgreSQLParserASSIGNMENT, PostgreSQLParserAT, PostgreSQLParserATTRIBUTE, PostgreSQLParserBACKWARD, PostgreSQLParserBEFORE, PostgreSQLParserBEGIN_P, PostgreSQLParserBY, PostgreSQLParserCACHE, PostgreSQLParserCALLED, PostgreSQLParserCASCADE, PostgreSQLParserCASCADED, PostgreSQLParserCATALOG, PostgreSQLParserCHAIN, PostgreSQLParserCHARACTERISTICS, PostgreSQLParserCHECKPOINT, PostgreSQLParserCLASS, PostgreSQLParserCLOSE, PostgreSQLParserCLUSTER, PostgreSQLParserCOMMENT, PostgreSQLParserCOMMENTS, PostgreSQLParserCOMMIT, PostgreSQLParserCOMMITTED, PostgreSQLParserCONFIGURATION, PostgreSQLParserCONNECTION, PostgreSQLParserCONSTRAINTS, PostgreSQLParserCONTENT_P, PostgreSQLParserCONTINUE_P, PostgreSQLParserCONVERSION_P, PostgreSQLParserCOPY, PostgreSQLParserCOST, PostgreSQLParserCSV, PostgreSQLParserCURSOR, PostgreSQLParserCYCLE, PostgreSQLParserDATA_P, PostgreSQLParserDATABASE, PostgreSQLParserDAY_P, PostgreSQLParserDEALLOCATE, PostgreSQLParserDECLARE, PostgreSQLParserDEFAULTS, PostgreSQLParserDEFERRED, PostgreSQLParserDEFINER, PostgreSQLParserDELETE_P, PostgreSQLParserDELIMITER, PostgreSQLParserDELIMITERS, PostgreSQLParserDICTIONARY, PostgreSQLParserDISABLE_P, PostgreSQLParserDISCARD, PostgreSQLParserDOCUMENT_P, PostgreSQLParserDOMAIN_P, PostgreSQLParserDOUBLE_P, PostgreSQLParserDROP, PostgreSQLParserEACH, PostgreSQLParserENABLE_P, PostgreSQLParserENCODING, PostgreSQLParserENCRYPTED, PostgreSQLParserENUM_P, PostgreSQLParserESCAPE, PostgreSQLParserEVENT, PostgreSQLParserEXCLUDE, PostgreSQLParserEXCLUDING, PostgreSQLParserEXCLUSIVE, PostgreSQLParserEXECUTE, PostgreSQLParserEXPLAIN, PostgreSQLParserEXTENSION, PostgreSQLParserEXTERNAL, PostgreSQLParserFAMILY, PostgreSQLParserFIRST_P, PostgreSQLParserFOLLOWING, PostgreSQLParserFORCE, PostgreSQLParserFORWARD, PostgreSQLParserFUNCTION, PostgreSQLParserFUNCTIONS, PostgreSQLParserGLOBAL, PostgreSQLParserGRANTED, PostgreSQLParserHANDLER, PostgreSQLParserHEADER_P, PostgreSQLParserHOLD, PostgreSQLParserHOUR_P, PostgreSQLParserIDENTITY_P, PostgreSQLParserIF_P, PostgreSQLParserIMMEDIATE, PostgreSQLParserIMMUTABLE, PostgreSQLParserIMPLICIT_P, PostgreSQLParserINCLUDING, PostgreSQLParserINCREMENT, PostgreSQLParserINDEX, PostgreSQLParserINDEXES, PostgreSQLParserINHERIT, PostgreSQLParserINHERITS, PostgreSQLParserINLINE_P, PostgreSQLParserINSENSITIVE, PostgreSQLParserINSERT, PostgreSQLParserINSTEAD, PostgreSQLParserINVOKER, PostgreSQLParserISOLATION, PostgreSQLParserKEY, PostgreSQLParserLABEL, PostgreSQLParserLANGUAGE, PostgreSQLParserLARGE_P, PostgreSQLParserLAST_P, PostgreSQLParserLEAKPROOF, PostgreSQLParserLEVEL, PostgreSQLParserLISTEN, PostgreSQLParserLOAD, PostgreSQLParserLOCAL, PostgreSQLParserLOCATION, PostgreSQLParserLOCK_P, PostgreSQLParserMAPPING, PostgreSQLParserMATCH, PostgreSQLParserMATERIALIZED, PostgreSQLParserMAXVALUE, PostgreSQLParserMINUTE_P, PostgreSQLParserMINVALUE, PostgreSQLParserMODE, PostgreSQLParserMONTH_P, PostgreSQLParserMOVE, PostgreSQLParserNAME_P, PostgreSQLParserNAMES, PostgreSQLParserNEXT, PostgreSQLParserNO, PostgreSQLParserNOTHING, PostgreSQLParserNOTIFY, PostgreSQLParserNOWAIT, PostgreSQLParserNULLS_P, PostgreSQLParserOBJECT_P, PostgreSQLParserOF, PostgreSQLParserOFF, PostgreSQLParserOIDS, PostgreSQLParserOPERATOR, PostgreSQLParserOPTION, PostgreSQLParserOPTIONS, PostgreSQLParserOWNED, PostgreSQLParserOWNER, PostgreSQLParserPARSER, PostgreSQLParserPARTIAL, PostgreSQLParserPARTITION, PostgreSQLParserPASSING, PostgreSQLParserPASSWORD, PostgreSQLParserPLANS, PostgreSQLParserPRECEDING, PostgreSQLParserPREPARE, PostgreSQLParserPREPARED, PostgreSQLParserPRESERVE, PostgreSQLParserPRIOR, PostgreSQLParserPRIVILEGES, PostgreSQLParserPROCEDURAL, PostgreSQLParserPROCEDURE, PostgreSQLParserPROGRAM, PostgreSQLParserQUOTE, PostgreSQLParserRANGE, PostgreSQLParserREAD, PostgreSQLParserREASSIGN, PostgreSQLParserRECHECK, PostgreSQLParserRECURSIVE, PostgreSQLParserREF, PostgreSQLParserREFRESH, PostgreSQLParserREINDEX, PostgreSQLParserRELATIVE_P, PostgreSQLParserRELEASE, PostgreSQLParserRENAME, PostgreSQLParserREPEATABLE, PostgreSQLParserREPLACE, PostgreSQLParserREPLICA, PostgreSQLParserRESET, PostgreSQLParserRESTART, PostgreSQLParserRESTRICT, PostgreSQLParserRETURNS, PostgreSQLParserREVOKE, PostgreSQLParserROLE, PostgreSQLParserROLLBACK, PostgreSQLParserROWS, PostgreSQLParserRULE, PostgreSQLParserSAVEPOINT, PostgreSQLParserSCHEMA, PostgreSQLParserSCROLL, PostgreSQLParserSEARCH, PostgreSQLParserSECOND_P, PostgreSQLParserSECURITY, PostgreSQLParserSEQUENCE, PostgreSQLParserSEQUENCES, PostgreSQLParserSERIALIZABLE, PostgreSQLParserSERVER, PostgreSQLParserSESSION, PostgreSQLParserSET, PostgreSQLParserSHARE, PostgreSQLParserSHOW, PostgreSQLParserSIMPLE, PostgreSQLParserSNAPSHOT, PostgreSQLParserSTABLE, PostgreSQLParserSTANDALONE_P, PostgreSQLParserSTART, PostgreSQLParserSTATEMENT, PostgreSQLParserSTATISTICS, PostgreSQLParserSTDIN, PostgreSQLParserSTDOUT, PostgreSQLParserSTORAGE, PostgreSQLParserSTRICT_P, PostgreSQLParserSTRIP_P, PostgreSQLParserSYSID, PostgreSQLParserSYSTEM_P, PostgreSQLParserTABLES, PostgreSQLParserTABLESPACE, PostgreSQLParserTEMP, PostgreSQLParserTEMPLATE, PostgreSQLParserTEMPORARY, PostgreSQLParserTEXT_P, PostgreSQLParserTRANSACTION, PostgreSQLParserTRIGGER, PostgreSQLParserTRUNCATE, PostgreSQLParserTRUSTED, PostgreSQLParserTYPE_P, PostgreSQLParserTYPES_P, PostgreSQLParserUNBOUNDED, PostgreSQLParserUNCOMMITTED, PostgreSQLParserUNENCRYPTED, PostgreSQLParserUNKNOWN, PostgreSQLParserUNLISTEN, PostgreSQLParserUNLOGGED, PostgreSQLParserUNTIL, PostgreSQLParserUPDATE, PostgreSQLParserVACUUM, PostgreSQLParserVALID, PostgreSQLParserVALIDATE, PostgreSQLParserVALIDATOR, PostgreSQLParserVARYING, PostgreSQLParserVERSION_P, PostgreSQLParserVIEW, PostgreSQLParserVOLATILE, PostgreSQLParserWHITESPACE_P, PostgreSQLParserWITHOUT, PostgreSQLParserWORK, PostgreSQLParserWRAPPER, PostgreSQLParserWRITE, PostgreSQLParserXML_P, PostgreSQLParserYEAR_P, PostgreSQLParserYES_P, PostgreSQLParserZONE, PostgreSQLParserBETWEEN, PostgreSQLParserBIGINT, PostgreSQLParserBIT, PostgreSQLParserBOOLEAN_P, PostgreSQLParserCHAR_P, PostgreSQLParserCHARACTER, PostgreSQLParserCOALESCE, PostgreSQLParserDEC, PostgreSQLParserDECIMAL_P, PostgreSQLParserEXISTS, PostgreSQLParserEXTRACT, PostgreSQLParserFLOAT_P, PostgreSQLParserGREATEST, PostgreSQLParserINOUT, PostgreSQLParserINT_P, PostgreSQLParserINTEGER, PostgreSQLParserINTERVAL, PostgreSQLParserLEAST, PostgreSQLParserNATIONAL, PostgreSQLParserNCHAR, PostgreSQLParserNONE, PostgreSQLParserNULLIF, PostgreSQLParserNUMERIC, PostgreSQLParserOVERLAY, PostgreSQLParserPOSITION, PostgreSQLParserPRECISION, PostgreSQLParserREAL, PostgreSQLParserROW, PostgreSQLParserSETOF, PostgreSQLParserSMALLINT, PostgreSQLParserSUBSTRING, PostgreSQLParserTIME, PostgreSQLParserTIMESTAMP, PostgreSQLParserTREAT, PostgreSQLParserTRIM, PostgreSQLParserVALUES, PostgreSQLParserVARCHAR, PostgreSQLParserXMLATTRIBUTES, PostgreSQLParserXMLCOMMENT, PostgreSQLParserXMLAGG, PostgreSQLParserXML_IS_WELL_FORMED, PostgreSQLParserXML_IS_WELL_FORMED_DOCUMENT, PostgreSQLParserXML_IS_WELL_FORMED_CONTENT, PostgreSQLParserXPATH, PostgreSQLParserXPATH_EXISTS, PostgreSQLParserXMLCONCAT, PostgreSQLParserXMLELEMENT, PostgreSQLParserXMLEXISTS, PostgreSQLParserXMLFOREST, PostgreSQLParserXMLPARSE, PostgreSQLParserXMLPI, PostgreSQLParserXMLROOT, PostgreSQLParserXMLSERIALIZE, PostgreSQLParserCALL, PostgreSQLParserCURRENT_P, PostgreSQLParserATTACH, PostgreSQLParserDETACH, PostgreSQLParserEXPRESSION, PostgreSQLParserGENERATED, PostgreSQLParserLOGGED, PostgreSQLParserSTORED, PostgreSQLParserINCLUDE, PostgreSQLParserROUTINE, PostgreSQLParserTRANSFORM, PostgreSQLParserIMPORT_P, PostgreSQLParserPOLICY, PostgreSQLParserMETHOD, PostgreSQLParserREFERENCING, PostgreSQLParserNEW, PostgreSQLParserOLD, PostgreSQLParserVALUE_P, PostgreSQLParserSUBSCRIPTION, PostgreSQLParserPUBLICATION, PostgreSQLParserOUT_P, PostgreSQLParserROUTINES, PostgreSQLParserSCHEMAS, PostgreSQLParserPROCEDURES, PostgreSQLParserINPUT_P, PostgreSQLParserSUPPORT, PostgreSQLParserPARALLEL, PostgreSQLParserSQL_P, PostgreSQLParserDEPENDS, PostgreSQLParserOVERRIDING, PostgreSQLParserCONFLICT, PostgreSQLParserSKIP_P, PostgreSQLParserLOCKED, PostgreSQLParserTIES, PostgreSQLParserROLLUP, PostgreSQLParserCUBE, PostgreSQLParserGROUPING, PostgreSQLParserSETS, PostgreSQLParserTABLESAMPLE, PostgreSQLParserORDINALITY, PostgreSQLParserXMLTABLE, PostgreSQLParserCOLUMNS, PostgreSQLParserXMLNAMESPACES, PostgreSQLParserROWTYPE, PostgreSQLParserNORMALIZED, PostgreSQLParserWITHIN, PostgreSQLParserFILTER, PostgreSQLParserGROUPS, PostgreSQLParserOTHERS, PostgreSQLParserNFC, PostgreSQLParserNFD, PostgreSQLParserNFKC, PostgreSQLParserNFKD, PostgreSQLParserUESCAPE, PostgreSQLParserVIEWS, PostgreSQLParserNORMALIZE, PostgreSQLParserDUMP, PostgreSQLParserPRINT_STRICT_PARAMS, PostgreSQLParserVARIABLE_CONFLICT, PostgreSQLParserERROR, PostgreSQLParserUSE_VARIABLE, PostgreSQLParserUSE_COLUMN, PostgreSQLParserALIAS, PostgreSQLParserCONSTANT, PostgreSQLParserPERFORM, PostgreSQLParserGET, PostgreSQLParserDIAGNOSTICS, PostgreSQLParserSTACKED, PostgreSQLParserELSIF, PostgreSQLParserREVERSE, PostgreSQLParserSLICE, PostgreSQLParserEXIT, PostgreSQLParserRETURN, PostgreSQLParserQUERY, PostgreSQLParserRAISE, PostgreSQLParserSQLSTATE, PostgreSQLParserDEBUG, PostgreSQLParserLOG, PostgreSQLParserINFO, PostgreSQLParserNOTICE, PostgreSQLParserWARNING, PostgreSQLParserEXCEPTION, PostgreSQLParserASSERT, PostgreSQLParserOPEN, PostgreSQLParserABS, PostgreSQLParserCBRT, PostgreSQLParserCEIL, PostgreSQLParserCEILING, PostgreSQLParserDEGREES, PostgreSQLParserDIV, PostgreSQLParserEXP, PostgreSQLParserFACTORIAL, PostgreSQLParserFLOOR, PostgreSQLParserGCD, PostgreSQLParserLCM, PostgreSQLParserLN, PostgreSQLParserLOG10, PostgreSQLParserMIN_SCALE, PostgreSQLParserMOD, PostgreSQLParserPI, PostgreSQLParserPOWER, PostgreSQLParserRADIANS, PostgreSQLParserROUND, PostgreSQLParserSCALE, PostgreSQLParserSIGN, PostgreSQLParserSQRT, PostgreSQLParserTRIM_SCALE, PostgreSQLParserTRUNC, PostgreSQLParserWIDTH_BUCKET, PostgreSQLParserRANDOM, PostgreSQLParserSETSEED, PostgreSQLParserACOS, PostgreSQLParserACOSD, PostgreSQLParserASIN, PostgreSQLParserASIND, PostgreSQLParserATAN, PostgreSQLParserATAND, PostgreSQLParserATAN2, PostgreSQLParserATAN2D, PostgreSQLParserCOS, PostgreSQLParserCOSD, PostgreSQLParserCOT, PostgreSQLParserCOTD, PostgreSQLParserSIN, PostgreSQLParserSIND, PostgreSQLParserTAN, PostgreSQLParserTAND, PostgreSQLParserSINH, PostgreSQLParserCOSH, PostgreSQLParserTANH, PostgreSQLParserASINH, PostgreSQLParserACOSH, PostgreSQLParserATANH, PostgreSQLParserBIT_LENGTH, PostgreSQLParserCHAR_LENGTH, PostgreSQLParserCHARACTER_LENGTH, PostgreSQLParserLOWER, PostgreSQLParserOCTET_LENGTH, PostgreSQLParserUPPER, PostgreSQLParserASCII, PostgreSQLParserBTRIM, PostgreSQLParserCHR, PostgreSQLParserCONCAT, PostgreSQLParserCONCAT_WS, PostgreSQLParserFORMAT, PostgreSQLParserINITCAP, PostgreSQLParserLENGTH, PostgreSQLParserLPAD, PostgreSQLParserLTRIM, PostgreSQLParserMD5, PostgreSQLParserPARSE_IDENT, PostgreSQLParserPG_CLIENT_ENCODING, PostgreSQLParserQUOTE_IDENT, PostgreSQLParserQUOTE_LITERAL, PostgreSQLParserQUOTE_NULLABLE, PostgreSQLParserREGEXP_COUNT, PostgreSQLParserREGEXP_INSTR, PostgreSQLParserREGEXP_LIKE, PostgreSQLParserREGEXP_MATCH, PostgreSQLParserREGEXP_MATCHES, PostgreSQLParserREGEXP_REPLACE, PostgreSQLParserREGEXP_SPLIT_TO_ARRAY, PostgreSQLParserREGEXP_SPLIT_TO_TABLE, PostgreSQLParserREGEXP_SUBSTR, PostgreSQLParserREPEAT, PostgreSQLParserRPAD, PostgreSQLParserRTRIM, PostgreSQLParserSPLIT_PART, PostgreSQLParserSTARTS_WITH, PostgreSQLParserSTRING_TO_ARRAY, PostgreSQLParserSTRING_TO_TABLE, PostgreSQLParserSTRPOS, PostgreSQLParserSUBSTR, PostgreSQLParserTO_ASCII, PostgreSQLParserTO_HEX, PostgreSQLParserTRANSLATE, PostgreSQLParserUNISTR, PostgreSQLParserAGE, PostgreSQLParserCLOCK_TIMESTAMP, PostgreSQLParserDATE_BIN, PostgreSQLParserDATE_PART, PostgreSQLParserDATE_TRUNC, PostgreSQLParserISFINITE, PostgreSQLParserJUSTIFY_DAYS, PostgreSQLParserJUSTIFY_HOURS, PostgreSQLParserJUSTIFY_INTERVAL, PostgreSQLParserMAKE_DATE, PostgreSQLParserMAKE_INTERVAL, PostgreSQLParserMAKE_TIME, PostgreSQLParserMAKE_TIMESTAMP, PostgreSQLParserMAKE_TIMESTAMPTZ, PostgreSQLParserNOW, PostgreSQLParserSTATEMENT_TIMESTAMP, PostgreSQLParserTIMEOFDAY, PostgreSQLParserTRANSACTION_TIMESTAMP, PostgreSQLParserTO_TIMESTAMP, PostgreSQLParserTO_CHAR, PostgreSQLParserTO_DATE, PostgreSQLParserTO_NUMBER, PostgreSQLParserIdentifier, PostgreSQLParserQuotedIdentifier, PostgreSQLParserUnicodeQuotedIdentifier, PostgreSQLParserPLSQLVARIABLENAME, PostgreSQLParserPLSQLIDENTIFIER:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(9832)
			p.Nonreservedword()
		}

	case PostgreSQLParserCURRENT_USER:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(9833)
			p.Match(PostgreSQLParserCURRENT_USER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case PostgreSQLParserSESSION_USER:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(9834)
			p.Match(PostgreSQLParserSESSION_USER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	default:
		p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IRole_listContext is an interface to support dynamic dispatch.
type IRole_listContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	AllRolespec() []IRolespecContext
	Rolespec(i int) IRolespecContext
	AllCOMMA() []antlr.TerminalNode
	COMMA(i int) antlr.TerminalNode

	// IsRole_listContext differentiates from other interfaces.
	IsRole_listContext()
}

type Role_listContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyRole_listContext() *Role_listContext {
	var p = new(Role_listContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_role_list
	return p
}

func InitEmptyRole_listContext(p *Role_listContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_role_list
}

func (*Role_listContext) IsRole_listContext() {}

func NewRole_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Role_listContext {
	var p = new(Role_listContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_role_list

	return p
}

func (s *Role_listContext) GetParser() antlr.Parser { return s.parser }

func (s *Role_listContext) AllRolespec() []IRolespecContext {
	children := s.GetChildren()
	len := 0
	for _, ctx := range children {
		if _, ok := ctx.(IRolespecContext); ok {
			len++
		}
	}

	tst := make([]IRolespecContext, len)
	i := 0
	for _, ctx := range children {
		if t, ok := ctx.(IRolespecContext); ok {
			tst[i] = t.(IRolespecContext)
			i++
		}
	}

	return tst
}

func (s *Role_listContext) Rolespec(i int) IRolespecContext {
	var t antlr.RuleContext
	j := 0
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IRolespecContext); ok {
			if j == i {
				t = ctx.(antlr.RuleContext)
				break
			}
			j++
		}
	}

	if t == nil {
		return nil
	}

	return t.(IRolespecContext)
}

func (s *Role_listContext) AllCOMMA() []antlr.TerminalNode {
	return s.GetTokens(PostgreSQLParserCOMMA)
}

func (s *Role_listContext) COMMA(i int) antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCOMMA, i)
}

func (s *Role_listContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Role_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Role_listContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterRole_list(s)
	}
}

func (s *Role_listContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitRole_list(s)
	}
}

func (s *Role_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitRole_list(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Role_list() (localctx IRole_listContext) {
	localctx = NewRole_listContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1370, PostgreSQLParserRULE_role_list)
	var _la int

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(9837)
		p.Rolespec()
	}
	p.SetState(9842)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}
	_la = p.GetTokenStream().LA(1)

	for _la == PostgreSQLParserCOMMA {
		{
			p.SetState(9838)
			p.Match(PostgreSQLParserCOMMA)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(9839)
			p.Rolespec()
		}

		p.SetState(9844)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}
		_la = p.GetTokenStream().LA(1)
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IColidContext is an interface to support dynamic dispatch.
type IColidContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Identifier() IIdentifierContext
	Unreserved_keyword() IUnreserved_keywordContext
	Col_name_keyword() ICol_name_keywordContext
	Plsql_unreserved_keyword() IPlsql_unreserved_keywordContext
	LEFT() antlr.TerminalNode
	RIGHT() antlr.TerminalNode

	// IsColidContext differentiates from other interfaces.
	IsColidContext()
}

type ColidContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyColidContext() *ColidContext {
	var p = new(ColidContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_colid
	return p
}

func InitEmptyColidContext(p *ColidContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_colid
}

func (*ColidContext) IsColidContext() {}

func NewColidContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ColidContext {
	var p = new(ColidContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_colid

	return p
}

func (s *ColidContext) GetParser() antlr.Parser { return s.parser }

func (s *ColidContext) Identifier() IIdentifierContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IIdentifierContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IIdentifierContext)
}

func (s *ColidContext) Unreserved_keyword() IUnreserved_keywordContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IUnreserved_keywordContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IUnreserved_keywordContext)
}

func (s *ColidContext) Col_name_keyword() ICol_name_keywordContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ICol_name_keywordContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ICol_name_keywordContext)
}

func (s *ColidContext) Plsql_unreserved_keyword() IPlsql_unreserved_keywordContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IPlsql_unreserved_keywordContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IPlsql_unreserved_keywordContext)
}

func (s *ColidContext) LEFT() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserLEFT, 0)
}

func (s *ColidContext) RIGHT() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserRIGHT, 0)
}

func (s *ColidContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *ColidContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *ColidContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterColid(s)
	}
}

func (s *ColidContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitColid(s)
	}
}

func (s *ColidContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitColid(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Colid() (localctx IColidContext) {
	localctx = NewColidContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1372, PostgreSQLParserRULE_colid)
	p.SetState(9851)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 658, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(9845)
			p.Identifier()
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(9846)
			p.Unreserved_keyword()
		}

	case 3:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(9847)
			p.Col_name_keyword()
		}

	case 4:
		p.EnterOuterAlt(localctx, 4)
		{
			p.SetState(9848)
			p.Plsql_unreserved_keyword()
		}

	case 5:
		p.EnterOuterAlt(localctx, 5)
		{
			p.SetState(9849)
			p.Match(PostgreSQLParserLEFT)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 6:
		p.EnterOuterAlt(localctx, 6)
		{
			p.SetState(9850)
			p.Match(PostgreSQLParserRIGHT)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case antlr.ATNInvalidAltNumber:
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// ITable_aliasContext is an interface to support dynamic dispatch.
type ITable_aliasContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Identifier() IIdentifierContext
	Unreserved_keyword() IUnreserved_keywordContext
	Col_name_keyword() ICol_name_keywordContext
	Plsql_unreserved_keyword() IPlsql_unreserved_keywordContext

	// IsTable_aliasContext differentiates from other interfaces.
	IsTable_aliasContext()
}

type Table_aliasContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyTable_aliasContext() *Table_aliasContext {
	var p = new(Table_aliasContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_table_alias
	return p
}

func InitEmptyTable_aliasContext(p *Table_aliasContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_table_alias
}

func (*Table_aliasContext) IsTable_aliasContext() {}

func NewTable_aliasContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Table_aliasContext {
	var p = new(Table_aliasContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_table_alias

	return p
}

func (s *Table_aliasContext) GetParser() antlr.Parser { return s.parser }

func (s *Table_aliasContext) Identifier() IIdentifierContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IIdentifierContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IIdentifierContext)
}

func (s *Table_aliasContext) Unreserved_keyword() IUnreserved_keywordContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IUnreserved_keywordContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IUnreserved_keywordContext)
}

func (s *Table_aliasContext) Col_name_keyword() ICol_name_keywordContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ICol_name_keywordContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ICol_name_keywordContext)
}

func (s *Table_aliasContext) Plsql_unreserved_keyword() IPlsql_unreserved_keywordContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IPlsql_unreserved_keywordContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IPlsql_unreserved_keywordContext)
}

func (s *Table_aliasContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Table_aliasContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Table_aliasContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterTable_alias(s)
	}
}

func (s *Table_aliasContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitTable_alias(s)
	}
}

func (s *Table_aliasContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitTable_alias(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Table_alias() (localctx ITable_aliasContext) {
	localctx = NewTable_aliasContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1374, PostgreSQLParserRULE_table_alias)
	p.SetState(9857)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 659, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(9853)
			p.Identifier()
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(9854)
			p.Unreserved_keyword()
		}

	case 3:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(9855)
			p.Col_name_keyword()
		}

	case 4:
		p.EnterOuterAlt(localctx, 4)
		{
			p.SetState(9856)
			p.Plsql_unreserved_keyword()
		}

	case antlr.ATNInvalidAltNumber:
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IType_function_nameContext is an interface to support dynamic dispatch.
type IType_function_nameContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Identifier() IIdentifierContext
	Unreserved_keyword() IUnreserved_keywordContext
	Plsql_unreserved_keyword() IPlsql_unreserved_keywordContext
	Type_func_name_keyword() IType_func_name_keywordContext

	// IsType_function_nameContext differentiates from other interfaces.
	IsType_function_nameContext()
}

type Type_function_nameContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyType_function_nameContext() *Type_function_nameContext {
	var p = new(Type_function_nameContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_type_function_name
	return p
}

func InitEmptyType_function_nameContext(p *Type_function_nameContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_type_function_name
}

func (*Type_function_nameContext) IsType_function_nameContext() {}

func NewType_function_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Type_function_nameContext {
	var p = new(Type_function_nameContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_type_function_name

	return p
}

func (s *Type_function_nameContext) GetParser() antlr.Parser { return s.parser }

func (s *Type_function_nameContext) Identifier() IIdentifierContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IIdentifierContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IIdentifierContext)
}

func (s *Type_function_nameContext) Unreserved_keyword() IUnreserved_keywordContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IUnreserved_keywordContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IUnreserved_keywordContext)
}

func (s *Type_function_nameContext) Plsql_unreserved_keyword() IPlsql_unreserved_keywordContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IPlsql_unreserved_keywordContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IPlsql_unreserved_keywordContext)
}

func (s *Type_function_nameContext) Type_func_name_keyword() IType_func_name_keywordContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IType_func_name_keywordContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IType_func_name_keywordContext)
}

func (s *Type_function_nameContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Type_function_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Type_function_nameContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterType_function_name(s)
	}
}

func (s *Type_function_nameContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitType_function_name(s)
	}
}

func (s *Type_function_nameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitType_function_name(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Type_function_name() (localctx IType_function_nameContext) {
	localctx = NewType_function_nameContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1376, PostgreSQLParserRULE_type_function_name)
	p.SetState(9863)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 660, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(9859)
			p.Identifier()
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(9860)
			p.Unreserved_keyword()
		}

	case 3:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(9861)
			p.Plsql_unreserved_keyword()
		}

	case 4:
		p.EnterOuterAlt(localctx, 4)
		{
			p.SetState(9862)
			p.Type_func_name_keyword()
		}

	case antlr.ATNInvalidAltNumber:
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// INonreservedwordContext is an interface to support dynamic dispatch.
type INonreservedwordContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Identifier() IIdentifierContext
	Unreserved_keyword() IUnreserved_keywordContext
	Col_name_keyword() ICol_name_keywordContext
	Type_func_name_keyword() IType_func_name_keywordContext

	// IsNonreservedwordContext differentiates from other interfaces.
	IsNonreservedwordContext()
}

type NonreservedwordContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyNonreservedwordContext() *NonreservedwordContext {
	var p = new(NonreservedwordContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_nonreservedword
	return p
}

func InitEmptyNonreservedwordContext(p *NonreservedwordContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_nonreservedword
}

func (*NonreservedwordContext) IsNonreservedwordContext() {}

func NewNonreservedwordContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *NonreservedwordContext {
	var p = new(NonreservedwordContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_nonreservedword

	return p
}

func (s *NonreservedwordContext) GetParser() antlr.Parser { return s.parser }

func (s *NonreservedwordContext) Identifier() IIdentifierContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IIdentifierContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IIdentifierContext)
}

func (s *NonreservedwordContext) Unreserved_keyword() IUnreserved_keywordContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IUnreserved_keywordContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IUnreserved_keywordContext)
}

func (s *NonreservedwordContext) Col_name_keyword() ICol_name_keywordContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ICol_name_keywordContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ICol_name_keywordContext)
}

func (s *NonreservedwordContext) Type_func_name_keyword() IType_func_name_keywordContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IType_func_name_keywordContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IType_func_name_keywordContext)
}

func (s *NonreservedwordContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *NonreservedwordContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *NonreservedwordContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterNonreservedword(s)
	}
}

func (s *NonreservedwordContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitNonreservedword(s)
	}
}

func (s *NonreservedwordContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitNonreservedword(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Nonreservedword() (localctx INonreservedwordContext) {
	localctx = NewNonreservedwordContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1378, PostgreSQLParserRULE_nonreservedword)
	p.SetState(9869)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 661, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(9865)
			p.Identifier()
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(9866)
			p.Unreserved_keyword()
		}

	case 3:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(9867)
			p.Col_name_keyword()
		}

	case 4:
		p.EnterOuterAlt(localctx, 4)
		{
			p.SetState(9868)
			p.Type_func_name_keyword()
		}

	case antlr.ATNInvalidAltNumber:
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// ICollabelContext is an interface to support dynamic dispatch.
type ICollabelContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Identifier() IIdentifierContext
	Plsql_unreserved_keyword() IPlsql_unreserved_keywordContext
	Unreserved_keyword() IUnreserved_keywordContext
	Col_name_keyword() ICol_name_keywordContext
	Type_func_name_keyword() IType_func_name_keywordContext
	Reserved_keyword() IReserved_keywordContext

	// IsCollabelContext differentiates from other interfaces.
	IsCollabelContext()
}

type CollabelContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyCollabelContext() *CollabelContext {
	var p = new(CollabelContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_collabel
	return p
}

func InitEmptyCollabelContext(p *CollabelContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_collabel
}

func (*CollabelContext) IsCollabelContext() {}

func NewCollabelContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CollabelContext {
	var p = new(CollabelContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_collabel

	return p
}

func (s *CollabelContext) GetParser() antlr.Parser { return s.parser }

func (s *CollabelContext) Identifier() IIdentifierContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IIdentifierContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IIdentifierContext)
}

func (s *CollabelContext) Plsql_unreserved_keyword() IPlsql_unreserved_keywordContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IPlsql_unreserved_keywordContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IPlsql_unreserved_keywordContext)
}

func (s *CollabelContext) Unreserved_keyword() IUnreserved_keywordContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IUnreserved_keywordContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IUnreserved_keywordContext)
}

func (s *CollabelContext) Col_name_keyword() ICol_name_keywordContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ICol_name_keywordContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ICol_name_keywordContext)
}

func (s *CollabelContext) Type_func_name_keyword() IType_func_name_keywordContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IType_func_name_keywordContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IType_func_name_keywordContext)
}

func (s *CollabelContext) Reserved_keyword() IReserved_keywordContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IReserved_keywordContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IReserved_keywordContext)
}

func (s *CollabelContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *CollabelContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *CollabelContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterCollabel(s)
	}
}

func (s *CollabelContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitCollabel(s)
	}
}

func (s *CollabelContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitCollabel(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Collabel() (localctx ICollabelContext) {
	localctx = NewCollabelContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1380, PostgreSQLParserRULE_collabel)
	p.SetState(9877)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 662, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(9871)
			p.Identifier()
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(9872)
			p.Plsql_unreserved_keyword()
		}

	case 3:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(9873)
			p.Unreserved_keyword()
		}

	case 4:
		p.EnterOuterAlt(localctx, 4)
		{
			p.SetState(9874)
			p.Col_name_keyword()
		}

	case 5:
		p.EnterOuterAlt(localctx, 5)
		{
			p.SetState(9875)
			p.Type_func_name_keyword()
		}

	case 6:
		p.EnterOuterAlt(localctx, 6)
		{
			p.SetState(9876)
			p.Reserved_keyword()
		}

	case antlr.ATNInvalidAltNumber:
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IIdentifierContext is an interface to support dynamic dispatch.
type IIdentifierContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Identifier() antlr.TerminalNode
	Opt_uescape() IOpt_uescapeContext
	QuotedIdentifier() antlr.TerminalNode
	UnicodeQuotedIdentifier() antlr.TerminalNode
	Plsqlvariablename() IPlsqlvariablenameContext
	Plsqlidentifier() IPlsqlidentifierContext
	Plsql_unreserved_keyword() IPlsql_unreserved_keywordContext

	// IsIdentifierContext differentiates from other interfaces.
	IsIdentifierContext()
}

type IdentifierContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyIdentifierContext() *IdentifierContext {
	var p = new(IdentifierContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_identifier
	return p
}

func InitEmptyIdentifierContext(p *IdentifierContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_identifier
}

func (*IdentifierContext) IsIdentifierContext() {}

func NewIdentifierContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *IdentifierContext {
	var p = new(IdentifierContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_identifier

	return p
}

func (s *IdentifierContext) GetParser() antlr.Parser { return s.parser }

func (s *IdentifierContext) Identifier() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserIdentifier, 0)
}

func (s *IdentifierContext) Opt_uescape() IOpt_uescapeContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOpt_uescapeContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOpt_uescapeContext)
}

func (s *IdentifierContext) QuotedIdentifier() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserQuotedIdentifier, 0)
}

func (s *IdentifierContext) UnicodeQuotedIdentifier() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserUnicodeQuotedIdentifier, 0)
}

func (s *IdentifierContext) Plsqlvariablename() IPlsqlvariablenameContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IPlsqlvariablenameContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IPlsqlvariablenameContext)
}

func (s *IdentifierContext) Plsqlidentifier() IPlsqlidentifierContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IPlsqlidentifierContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IPlsqlidentifierContext)
}

func (s *IdentifierContext) Plsql_unreserved_keyword() IPlsql_unreserved_keywordContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IPlsql_unreserved_keywordContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IPlsql_unreserved_keywordContext)
}

func (s *IdentifierContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *IdentifierContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *IdentifierContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterIdentifier(s)
	}
}

func (s *IdentifierContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitIdentifier(s)
	}
}

func (s *IdentifierContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitIdentifier(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Identifier() (localctx IIdentifierContext) {
	localctx = NewIdentifierContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1382, PostgreSQLParserRULE_identifier)
	p.SetState(9886)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetTokenStream().LA(1) {
	case PostgreSQLParserIdentifier:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(9879)
			p.Match(PostgreSQLParserIdentifier)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(9880)
			p.Opt_uescape()
		}

	case PostgreSQLParserQuotedIdentifier:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(9881)
			p.Match(PostgreSQLParserQuotedIdentifier)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case PostgreSQLParserUnicodeQuotedIdentifier:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(9882)
			p.Match(PostgreSQLParserUnicodeQuotedIdentifier)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case PostgreSQLParserPLSQLVARIABLENAME:
		p.EnterOuterAlt(localctx, 4)
		{
			p.SetState(9883)
			p.Plsqlvariablename()
		}

	case PostgreSQLParserPLSQLIDENTIFIER:
		p.EnterOuterAlt(localctx, 5)
		{
			p.SetState(9884)
			p.Plsqlidentifier()
		}

	case PostgreSQLParserAND, PostgreSQLParserARRAY, PostgreSQLParserCOLLATE, PostgreSQLParserCOLUMN, PostgreSQLParserCONSTRAINT, PostgreSQLParserDEFAULT, PostgreSQLParserDO, PostgreSQLParserFETCH, PostgreSQLParserTABLE, PostgreSQLParserIS, PostgreSQLParserOUTER_P, PostgreSQLParserABSOLUTE_P, PostgreSQLParserBACKWARD, PostgreSQLParserCHAIN, PostgreSQLParserCLOSE, PostgreSQLParserCOMMIT, PostgreSQLParserCONTINUE_P, PostgreSQLParserCURSOR, PostgreSQLParserFIRST_P, PostgreSQLParserFORWARD, PostgreSQLParserINSERT, PostgreSQLParserLAST_P, PostgreSQLParserMOVE, PostgreSQLParserNEXT, PostgreSQLParserNO, PostgreSQLParserOPTION, PostgreSQLParserPRIOR, PostgreSQLParserRELATIVE_P, PostgreSQLParserRESET, PostgreSQLParserROLLBACK, PostgreSQLParserSCHEMA, PostgreSQLParserSCROLL, PostgreSQLParserSET, PostgreSQLParserTYPE_P, PostgreSQLParserCALL, PostgreSQLParserCURRENT_P, PostgreSQLParserROWTYPE, PostgreSQLParserDUMP, PostgreSQLParserPRINT_STRICT_PARAMS, PostgreSQLParserVARIABLE_CONFLICT, PostgreSQLParserERROR, PostgreSQLParserUSE_VARIABLE, PostgreSQLParserUSE_COLUMN, PostgreSQLParserALIAS, PostgreSQLParserCONSTANT, PostgreSQLParserPERFORM, PostgreSQLParserGET, PostgreSQLParserDIAGNOSTICS, PostgreSQLParserSTACKED, PostgreSQLParserELSIF, PostgreSQLParserSLICE, PostgreSQLParserEXIT, PostgreSQLParserRETURN, PostgreSQLParserQUERY, PostgreSQLParserRAISE, PostgreSQLParserSQLSTATE, PostgreSQLParserDEBUG, PostgreSQLParserINFO, PostgreSQLParserNOTICE, PostgreSQLParserWARNING, PostgreSQLParserEXCEPTION, PostgreSQLParserASSERT, PostgreSQLParserOPEN:
		p.EnterOuterAlt(localctx, 6)
		{
			p.SetState(9885)
			p.Plsql_unreserved_keyword()
		}

	default:
		p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IPlsqlidentifierContext is an interface to support dynamic dispatch.
type IPlsqlidentifierContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	PLSQLIDENTIFIER() antlr.TerminalNode

	// IsPlsqlidentifierContext differentiates from other interfaces.
	IsPlsqlidentifierContext()
}

type PlsqlidentifierContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyPlsqlidentifierContext() *PlsqlidentifierContext {
	var p = new(PlsqlidentifierContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_plsqlidentifier
	return p
}

func InitEmptyPlsqlidentifierContext(p *PlsqlidentifierContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_plsqlidentifier
}

func (*PlsqlidentifierContext) IsPlsqlidentifierContext() {}

func NewPlsqlidentifierContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *PlsqlidentifierContext {
	var p = new(PlsqlidentifierContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_plsqlidentifier

	return p
}

func (s *PlsqlidentifierContext) GetParser() antlr.Parser { return s.parser }

func (s *PlsqlidentifierContext) PLSQLIDENTIFIER() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserPLSQLIDENTIFIER, 0)
}

func (s *PlsqlidentifierContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *PlsqlidentifierContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *PlsqlidentifierContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterPlsqlidentifier(s)
	}
}

func (s *PlsqlidentifierContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitPlsqlidentifier(s)
	}
}

func (s *PlsqlidentifierContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitPlsqlidentifier(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Plsqlidentifier() (localctx IPlsqlidentifierContext) {
	localctx = NewPlsqlidentifierContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1384, PostgreSQLParserRULE_plsqlidentifier)
	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(9888)
		p.Match(PostgreSQLParserPLSQLIDENTIFIER)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IUnreserved_keywordContext is an interface to support dynamic dispatch.
type IUnreserved_keywordContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	ABORT_P() antlr.TerminalNode
	ABSOLUTE_P() antlr.TerminalNode
	ACCESS() antlr.TerminalNode
	ACTION() antlr.TerminalNode
	ADD_P() antlr.TerminalNode
	ADMIN() antlr.TerminalNode
	AFTER() antlr.TerminalNode
	AGGREGATE() antlr.TerminalNode
	ALSO() antlr.TerminalNode
	ALTER() antlr.TerminalNode
	ALWAYS() antlr.TerminalNode
	ASSERTION() antlr.TerminalNode
	ASSIGNMENT() antlr.TerminalNode
	AT() antlr.TerminalNode
	ATTACH() antlr.TerminalNode
	ATTRIBUTE() antlr.TerminalNode
	BACKWARD() antlr.TerminalNode
	BEFORE() antlr.TerminalNode
	BEGIN_P() antlr.TerminalNode
	BY() antlr.TerminalNode
	CACHE() antlr.TerminalNode
	CALL() antlr.TerminalNode
	CALLED() antlr.TerminalNode
	CASCADE() antlr.TerminalNode
	CASCADED() antlr.TerminalNode
	CATALOG() antlr.TerminalNode
	CHAIN() antlr.TerminalNode
	CHARACTERISTICS() antlr.TerminalNode
	CHECKPOINT() antlr.TerminalNode
	CLASS() antlr.TerminalNode
	CLOSE() antlr.TerminalNode
	CLUSTER() antlr.TerminalNode
	COLUMNS() antlr.TerminalNode
	COMMENT() antlr.TerminalNode
	COMMENTS() antlr.TerminalNode
	COMMIT() antlr.TerminalNode
	COMMITTED() antlr.TerminalNode
	CONFIGURATION() antlr.TerminalNode
	CONFLICT() antlr.TerminalNode
	CONNECTION() antlr.TerminalNode
	CONSTRAINTS() antlr.TerminalNode
	CONTENT_P() antlr.TerminalNode
	CONTINUE_P() antlr.TerminalNode
	CONVERSION_P() antlr.TerminalNode
	COPY() antlr.TerminalNode
	COST() antlr.TerminalNode
	CSV() antlr.TerminalNode
	CUBE() antlr.TerminalNode
	CURRENT_P() antlr.TerminalNode
	CURSOR() antlr.TerminalNode
	CYCLE() antlr.TerminalNode
	DATA_P() antlr.TerminalNode
	DATABASE() antlr.TerminalNode
	DAY_P() antlr.TerminalNode
	DEALLOCATE() antlr.TerminalNode
	DECLARE() antlr.TerminalNode
	DEFAULTS() antlr.TerminalNode
	DEFERRED() antlr.TerminalNode
	DEFINER() antlr.TerminalNode
	DELETE_P() antlr.TerminalNode
	DELIMITER() antlr.TerminalNode
	DELIMITERS() antlr.TerminalNode
	DEPENDS() antlr.TerminalNode
	DETACH() antlr.TerminalNode
	DICTIONARY() antlr.TerminalNode
	DISABLE_P() antlr.TerminalNode
	DISCARD() antlr.TerminalNode
	DOCUMENT_P() antlr.TerminalNode
	DOMAIN_P() antlr.TerminalNode
	DOUBLE_P() antlr.TerminalNode
	DROP() antlr.TerminalNode
	EACH() antlr.TerminalNode
	ENABLE_P() antlr.TerminalNode
	ENCODING() antlr.TerminalNode
	ENCRYPTED() antlr.TerminalNode
	ENUM_P() antlr.TerminalNode
	ESCAPE() antlr.TerminalNode
	EVENT() antlr.TerminalNode
	EXCLUDE() antlr.TerminalNode
	EXCLUDING() antlr.TerminalNode
	EXCLUSIVE() antlr.TerminalNode
	EXECUTE() antlr.TerminalNode
	EXPLAIN() antlr.TerminalNode
	EXPRESSION() antlr.TerminalNode
	EXTENSION() antlr.TerminalNode
	EXTERNAL() antlr.TerminalNode
	FAMILY() antlr.TerminalNode
	FILTER() antlr.TerminalNode
	FIRST_P() antlr.TerminalNode
	FOLLOWING() antlr.TerminalNode
	FORCE() antlr.TerminalNode
	FORWARD() antlr.TerminalNode
	FUNCTION() antlr.TerminalNode
	FUNCTIONS() antlr.TerminalNode
	GENERATED() antlr.TerminalNode
	GLOBAL() antlr.TerminalNode
	GRANTED() antlr.TerminalNode
	GROUPS() antlr.TerminalNode
	HANDLER() antlr.TerminalNode
	HEADER_P() antlr.TerminalNode
	HOLD() antlr.TerminalNode
	HOUR_P() antlr.TerminalNode
	IDENTITY_P() antlr.TerminalNode
	IF_P() antlr.TerminalNode
	IMMEDIATE() antlr.TerminalNode
	IMMUTABLE() antlr.TerminalNode
	IMPLICIT_P() antlr.TerminalNode
	IMPORT_P() antlr.TerminalNode
	INCLUDE() antlr.TerminalNode
	INCLUDING() antlr.TerminalNode
	INCREMENT() antlr.TerminalNode
	INDEX() antlr.TerminalNode
	INDEXES() antlr.TerminalNode
	INHERIT() antlr.TerminalNode
	INHERITS() antlr.TerminalNode
	INLINE_P() antlr.TerminalNode
	INPUT_P() antlr.TerminalNode
	INSENSITIVE() antlr.TerminalNode
	INSERT() antlr.TerminalNode
	INSTEAD() antlr.TerminalNode
	INVOKER() antlr.TerminalNode
	ISOLATION() antlr.TerminalNode
	KEY() antlr.TerminalNode
	LABEL() antlr.TerminalNode
	LANGUAGE() antlr.TerminalNode
	LARGE_P() antlr.TerminalNode
	LAST_P() antlr.TerminalNode
	LEAKPROOF() antlr.TerminalNode
	LEVEL() antlr.TerminalNode
	LISTEN() antlr.TerminalNode
	LOAD() antlr.TerminalNode
	LOCAL() antlr.TerminalNode
	LOCATION() antlr.TerminalNode
	LOCK_P() antlr.TerminalNode
	LOCKED() antlr.TerminalNode
	LOGGED() antlr.TerminalNode
	MAPPING() antlr.TerminalNode
	MATCH() antlr.TerminalNode
	MATERIALIZED() antlr.TerminalNode
	MAXVALUE() antlr.TerminalNode
	METHOD() antlr.TerminalNode
	MINUTE_P() antlr.TerminalNode
	MINVALUE() antlr.TerminalNode
	MODE() antlr.TerminalNode
	MONTH_P() antlr.TerminalNode
	MOVE() antlr.TerminalNode
	NAME_P() antlr.TerminalNode
	NAMES() antlr.TerminalNode
	NEW() antlr.TerminalNode
	NEXT() antlr.TerminalNode
	NFC() antlr.TerminalNode
	NFD() antlr.TerminalNode
	NFKC() antlr.TerminalNode
	NFKD() antlr.TerminalNode
	NO() antlr.TerminalNode
	NORMALIZED() antlr.TerminalNode
	NOTHING() antlr.TerminalNode
	NOTIFY() antlr.TerminalNode
	NOWAIT() antlr.TerminalNode
	NULLS_P() antlr.TerminalNode
	OBJECT_P() antlr.TerminalNode
	OF() antlr.TerminalNode
	OFF() antlr.TerminalNode
	OIDS() antlr.TerminalNode
	OLD() antlr.TerminalNode
	OPERATOR() antlr.TerminalNode
	OPTION() antlr.TerminalNode
	OPTIONS() antlr.TerminalNode
	ORDINALITY() antlr.TerminalNode
	OTHERS() antlr.TerminalNode
	OVER() antlr.TerminalNode
	OVERRIDING() antlr.TerminalNode
	OWNED() antlr.TerminalNode
	OWNER() antlr.TerminalNode
	PARALLEL() antlr.TerminalNode
	PARSER() antlr.TerminalNode
	PARTIAL() antlr.TerminalNode
	PARTITION() antlr.TerminalNode
	PASSING() antlr.TerminalNode
	PASSWORD() antlr.TerminalNode
	PLANS() antlr.TerminalNode
	POLICY() antlr.TerminalNode
	PRECEDING() antlr.TerminalNode
	PREPARE() antlr.TerminalNode
	PREPARED() antlr.TerminalNode
	PRESERVE() antlr.TerminalNode
	PRIOR() antlr.TerminalNode
	PRIVILEGES() antlr.TerminalNode
	PROCEDURAL() antlr.TerminalNode
	PROCEDURE() antlr.TerminalNode
	PROCEDURES() antlr.TerminalNode
	PROGRAM() antlr.TerminalNode
	PUBLICATION() antlr.TerminalNode
	QUOTE() antlr.TerminalNode
	RANGE() antlr.TerminalNode
	READ() antlr.TerminalNode
	REASSIGN() antlr.TerminalNode
	RECHECK() antlr.TerminalNode
	RECURSIVE() antlr.TerminalNode
	REF() antlr.TerminalNode
	REFERENCING() antlr.TerminalNode
	REFRESH() antlr.TerminalNode
	REINDEX() antlr.TerminalNode
	RELATIVE_P() antlr.TerminalNode
	RELEASE() antlr.TerminalNode
	RENAME() antlr.TerminalNode
	REPEATABLE() antlr.TerminalNode
	REPLICA() antlr.TerminalNode
	RESET() antlr.TerminalNode
	RESTART() antlr.TerminalNode
	RESTRICT() antlr.TerminalNode
	RETURNS() antlr.TerminalNode
	REVOKE() antlr.TerminalNode
	ROLE() antlr.TerminalNode
	ROLLBACK() antlr.TerminalNode
	ROLLUP() antlr.TerminalNode
	ROUTINE() antlr.TerminalNode
	ROUTINES() antlr.TerminalNode
	ROWS() antlr.TerminalNode
	RULE() antlr.TerminalNode
	SAVEPOINT() antlr.TerminalNode
	SCHEMA() antlr.TerminalNode
	SCHEMAS() antlr.TerminalNode
	SCROLL() antlr.TerminalNode
	SEARCH() antlr.TerminalNode
	SECOND_P() antlr.TerminalNode
	SECURITY() antlr.TerminalNode
	SEQUENCE() antlr.TerminalNode
	SEQUENCES() antlr.TerminalNode
	SERIALIZABLE() antlr.TerminalNode
	SERVER() antlr.TerminalNode
	SESSION() antlr.TerminalNode
	SET() antlr.TerminalNode
	SETS() antlr.TerminalNode
	SHARE() antlr.TerminalNode
	SHOW() antlr.TerminalNode
	SIMPLE() antlr.TerminalNode
	SKIP_P() antlr.TerminalNode
	SNAPSHOT() antlr.TerminalNode
	SQL_P() antlr.TerminalNode
	STABLE() antlr.TerminalNode
	STANDALONE_P() antlr.TerminalNode
	START() antlr.TerminalNode
	STATEMENT() antlr.TerminalNode
	STATISTICS() antlr.TerminalNode
	STDIN() antlr.TerminalNode
	STDOUT() antlr.TerminalNode
	STORAGE() antlr.TerminalNode
	STORED() antlr.TerminalNode
	STRICT_P() antlr.TerminalNode
	STRIP_P() antlr.TerminalNode
	SUBSCRIPTION() antlr.TerminalNode
	SUPPORT() antlr.TerminalNode
	SYSID() antlr.TerminalNode
	SYSTEM_P() antlr.TerminalNode
	TABLES() antlr.TerminalNode
	TABLESPACE() antlr.TerminalNode
	TEMP() antlr.TerminalNode
	TEMPLATE() antlr.TerminalNode
	TEMPORARY() antlr.TerminalNode
	TEXT_P() antlr.TerminalNode
	TIES() antlr.TerminalNode
	TRANSACTION() antlr.TerminalNode
	TRANSFORM() antlr.TerminalNode
	TRIGGER() antlr.TerminalNode
	TRUNCATE() antlr.TerminalNode
	TRUSTED() antlr.TerminalNode
	TYPE_P() antlr.TerminalNode
	TYPES_P() antlr.TerminalNode
	UESCAPE() antlr.TerminalNode
	UNBOUNDED() antlr.TerminalNode
	UNCOMMITTED() antlr.TerminalNode
	UNENCRYPTED() antlr.TerminalNode
	UNKNOWN() antlr.TerminalNode
	UNLISTEN() antlr.TerminalNode
	UNLOGGED() antlr.TerminalNode
	UNTIL() antlr.TerminalNode
	UPDATE() antlr.TerminalNode
	VACUUM() antlr.TerminalNode
	VALID() antlr.TerminalNode
	VALIDATE() antlr.TerminalNode
	VALIDATOR() antlr.TerminalNode
	VALUE_P() antlr.TerminalNode
	VARYING() antlr.TerminalNode
	VERSION_P() antlr.TerminalNode
	VIEW() antlr.TerminalNode
	VIEWS() antlr.TerminalNode
	VOLATILE() antlr.TerminalNode
	WHITESPACE_P() antlr.TerminalNode
	WITHIN() antlr.TerminalNode
	WITHOUT() antlr.TerminalNode
	WORK() antlr.TerminalNode
	WRAPPER() antlr.TerminalNode
	WRITE() antlr.TerminalNode
	XML_P() antlr.TerminalNode
	YEAR_P() antlr.TerminalNode
	YES_P() antlr.TerminalNode
	ZONE() antlr.TerminalNode

	// IsUnreserved_keywordContext differentiates from other interfaces.
	IsUnreserved_keywordContext()
}

type Unreserved_keywordContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyUnreserved_keywordContext() *Unreserved_keywordContext {
	var p = new(Unreserved_keywordContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_unreserved_keyword
	return p
}

func InitEmptyUnreserved_keywordContext(p *Unreserved_keywordContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_unreserved_keyword
}

func (*Unreserved_keywordContext) IsUnreserved_keywordContext() {}

func NewUnreserved_keywordContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Unreserved_keywordContext {
	var p = new(Unreserved_keywordContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_unreserved_keyword

	return p
}

func (s *Unreserved_keywordContext) GetParser() antlr.Parser { return s.parser }

func (s *Unreserved_keywordContext) ABORT_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserABORT_P, 0)
}

func (s *Unreserved_keywordContext) ABSOLUTE_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserABSOLUTE_P, 0)
}

func (s *Unreserved_keywordContext) ACCESS() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserACCESS, 0)
}

func (s *Unreserved_keywordContext) ACTION() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserACTION, 0)
}

func (s *Unreserved_keywordContext) ADD_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserADD_P, 0)
}

func (s *Unreserved_keywordContext) ADMIN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserADMIN, 0)
}

func (s *Unreserved_keywordContext) AFTER() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserAFTER, 0)
}

func (s *Unreserved_keywordContext) AGGREGATE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserAGGREGATE, 0)
}

func (s *Unreserved_keywordContext) ALSO() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserALSO, 0)
}

func (s *Unreserved_keywordContext) ALTER() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserALTER, 0)
}

func (s *Unreserved_keywordContext) ALWAYS() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserALWAYS, 0)
}

func (s *Unreserved_keywordContext) ASSERTION() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserASSERTION, 0)
}

func (s *Unreserved_keywordContext) ASSIGNMENT() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserASSIGNMENT, 0)
}

func (s *Unreserved_keywordContext) AT() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserAT, 0)
}

func (s *Unreserved_keywordContext) ATTACH() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserATTACH, 0)
}

func (s *Unreserved_keywordContext) ATTRIBUTE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserATTRIBUTE, 0)
}

func (s *Unreserved_keywordContext) BACKWARD() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserBACKWARD, 0)
}

func (s *Unreserved_keywordContext) BEFORE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserBEFORE, 0)
}

func (s *Unreserved_keywordContext) BEGIN_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserBEGIN_P, 0)
}

func (s *Unreserved_keywordContext) BY() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserBY, 0)
}

func (s *Unreserved_keywordContext) CACHE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCACHE, 0)
}

func (s *Unreserved_keywordContext) CALL() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCALL, 0)
}

func (s *Unreserved_keywordContext) CALLED() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCALLED, 0)
}

func (s *Unreserved_keywordContext) CASCADE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCASCADE, 0)
}

func (s *Unreserved_keywordContext) CASCADED() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCASCADED, 0)
}

func (s *Unreserved_keywordContext) CATALOG() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCATALOG, 0)
}

func (s *Unreserved_keywordContext) CHAIN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCHAIN, 0)
}

func (s *Unreserved_keywordContext) CHARACTERISTICS() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCHARACTERISTICS, 0)
}

func (s *Unreserved_keywordContext) CHECKPOINT() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCHECKPOINT, 0)
}

func (s *Unreserved_keywordContext) CLASS() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCLASS, 0)
}

func (s *Unreserved_keywordContext) CLOSE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCLOSE, 0)
}

func (s *Unreserved_keywordContext) CLUSTER() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCLUSTER, 0)
}

func (s *Unreserved_keywordContext) COLUMNS() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCOLUMNS, 0)
}

func (s *Unreserved_keywordContext) COMMENT() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCOMMENT, 0)
}

func (s *Unreserved_keywordContext) COMMENTS() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCOMMENTS, 0)
}

func (s *Unreserved_keywordContext) COMMIT() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCOMMIT, 0)
}

func (s *Unreserved_keywordContext) COMMITTED() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCOMMITTED, 0)
}

func (s *Unreserved_keywordContext) CONFIGURATION() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCONFIGURATION, 0)
}

func (s *Unreserved_keywordContext) CONFLICT() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCONFLICT, 0)
}

func (s *Unreserved_keywordContext) CONNECTION() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCONNECTION, 0)
}

func (s *Unreserved_keywordContext) CONSTRAINTS() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCONSTRAINTS, 0)
}

func (s *Unreserved_keywordContext) CONTENT_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCONTENT_P, 0)
}

func (s *Unreserved_keywordContext) CONTINUE_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCONTINUE_P, 0)
}

func (s *Unreserved_keywordContext) CONVERSION_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCONVERSION_P, 0)
}

func (s *Unreserved_keywordContext) COPY() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCOPY, 0)
}

func (s *Unreserved_keywordContext) COST() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCOST, 0)
}

func (s *Unreserved_keywordContext) CSV() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCSV, 0)
}

func (s *Unreserved_keywordContext) CUBE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCUBE, 0)
}

func (s *Unreserved_keywordContext) CURRENT_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCURRENT_P, 0)
}

func (s *Unreserved_keywordContext) CURSOR() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCURSOR, 0)
}

func (s *Unreserved_keywordContext) CYCLE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCYCLE, 0)
}

func (s *Unreserved_keywordContext) DATA_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserDATA_P, 0)
}

func (s *Unreserved_keywordContext) DATABASE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserDATABASE, 0)
}

func (s *Unreserved_keywordContext) DAY_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserDAY_P, 0)
}

func (s *Unreserved_keywordContext) DEALLOCATE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserDEALLOCATE, 0)
}

func (s *Unreserved_keywordContext) DECLARE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserDECLARE, 0)
}

func (s *Unreserved_keywordContext) DEFAULTS() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserDEFAULTS, 0)
}

func (s *Unreserved_keywordContext) DEFERRED() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserDEFERRED, 0)
}

func (s *Unreserved_keywordContext) DEFINER() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserDEFINER, 0)
}

func (s *Unreserved_keywordContext) DELETE_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserDELETE_P, 0)
}

func (s *Unreserved_keywordContext) DELIMITER() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserDELIMITER, 0)
}

func (s *Unreserved_keywordContext) DELIMITERS() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserDELIMITERS, 0)
}

func (s *Unreserved_keywordContext) DEPENDS() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserDEPENDS, 0)
}

func (s *Unreserved_keywordContext) DETACH() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserDETACH, 0)
}

func (s *Unreserved_keywordContext) DICTIONARY() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserDICTIONARY, 0)
}

func (s *Unreserved_keywordContext) DISABLE_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserDISABLE_P, 0)
}

func (s *Unreserved_keywordContext) DISCARD() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserDISCARD, 0)
}

func (s *Unreserved_keywordContext) DOCUMENT_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserDOCUMENT_P, 0)
}

func (s *Unreserved_keywordContext) DOMAIN_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserDOMAIN_P, 0)
}

func (s *Unreserved_keywordContext) DOUBLE_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserDOUBLE_P, 0)
}

func (s *Unreserved_keywordContext) DROP() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserDROP, 0)
}

func (s *Unreserved_keywordContext) EACH() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserEACH, 0)
}

func (s *Unreserved_keywordContext) ENABLE_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserENABLE_P, 0)
}

func (s *Unreserved_keywordContext) ENCODING() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserENCODING, 0)
}

func (s *Unreserved_keywordContext) ENCRYPTED() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserENCRYPTED, 0)
}

func (s *Unreserved_keywordContext) ENUM_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserENUM_P, 0)
}

func (s *Unreserved_keywordContext) ESCAPE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserESCAPE, 0)
}

func (s *Unreserved_keywordContext) EVENT() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserEVENT, 0)
}

func (s *Unreserved_keywordContext) EXCLUDE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserEXCLUDE, 0)
}

func (s *Unreserved_keywordContext) EXCLUDING() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserEXCLUDING, 0)
}

func (s *Unreserved_keywordContext) EXCLUSIVE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserEXCLUSIVE, 0)
}

func (s *Unreserved_keywordContext) EXECUTE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserEXECUTE, 0)
}

func (s *Unreserved_keywordContext) EXPLAIN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserEXPLAIN, 0)
}

func (s *Unreserved_keywordContext) EXPRESSION() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserEXPRESSION, 0)
}

func (s *Unreserved_keywordContext) EXTENSION() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserEXTENSION, 0)
}

func (s *Unreserved_keywordContext) EXTERNAL() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserEXTERNAL, 0)
}

func (s *Unreserved_keywordContext) FAMILY() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserFAMILY, 0)
}

func (s *Unreserved_keywordContext) FILTER() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserFILTER, 0)
}

func (s *Unreserved_keywordContext) FIRST_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserFIRST_P, 0)
}

func (s *Unreserved_keywordContext) FOLLOWING() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserFOLLOWING, 0)
}

func (s *Unreserved_keywordContext) FORCE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserFORCE, 0)
}

func (s *Unreserved_keywordContext) FORWARD() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserFORWARD, 0)
}

func (s *Unreserved_keywordContext) FUNCTION() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserFUNCTION, 0)
}

func (s *Unreserved_keywordContext) FUNCTIONS() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserFUNCTIONS, 0)
}

func (s *Unreserved_keywordContext) GENERATED() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserGENERATED, 0)
}

func (s *Unreserved_keywordContext) GLOBAL() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserGLOBAL, 0)
}

func (s *Unreserved_keywordContext) GRANTED() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserGRANTED, 0)
}

func (s *Unreserved_keywordContext) GROUPS() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserGROUPS, 0)
}

func (s *Unreserved_keywordContext) HANDLER() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserHANDLER, 0)
}

func (s *Unreserved_keywordContext) HEADER_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserHEADER_P, 0)
}

func (s *Unreserved_keywordContext) HOLD() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserHOLD, 0)
}

func (s *Unreserved_keywordContext) HOUR_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserHOUR_P, 0)
}

func (s *Unreserved_keywordContext) IDENTITY_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserIDENTITY_P, 0)
}

func (s *Unreserved_keywordContext) IF_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserIF_P, 0)
}

func (s *Unreserved_keywordContext) IMMEDIATE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserIMMEDIATE, 0)
}

func (s *Unreserved_keywordContext) IMMUTABLE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserIMMUTABLE, 0)
}

func (s *Unreserved_keywordContext) IMPLICIT_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserIMPLICIT_P, 0)
}

func (s *Unreserved_keywordContext) IMPORT_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserIMPORT_P, 0)
}

func (s *Unreserved_keywordContext) INCLUDE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserINCLUDE, 0)
}

func (s *Unreserved_keywordContext) INCLUDING() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserINCLUDING, 0)
}

func (s *Unreserved_keywordContext) INCREMENT() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserINCREMENT, 0)
}

func (s *Unreserved_keywordContext) INDEX() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserINDEX, 0)
}

func (s *Unreserved_keywordContext) INDEXES() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserINDEXES, 0)
}

func (s *Unreserved_keywordContext) INHERIT() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserINHERIT, 0)
}

func (s *Unreserved_keywordContext) INHERITS() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserINHERITS, 0)
}

func (s *Unreserved_keywordContext) INLINE_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserINLINE_P, 0)
}

func (s *Unreserved_keywordContext) INPUT_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserINPUT_P, 0)
}

func (s *Unreserved_keywordContext) INSENSITIVE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserINSENSITIVE, 0)
}

func (s *Unreserved_keywordContext) INSERT() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserINSERT, 0)
}

func (s *Unreserved_keywordContext) INSTEAD() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserINSTEAD, 0)
}

func (s *Unreserved_keywordContext) INVOKER() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserINVOKER, 0)
}

func (s *Unreserved_keywordContext) ISOLATION() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserISOLATION, 0)
}

func (s *Unreserved_keywordContext) KEY() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserKEY, 0)
}

func (s *Unreserved_keywordContext) LABEL() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserLABEL, 0)
}

func (s *Unreserved_keywordContext) LANGUAGE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserLANGUAGE, 0)
}

func (s *Unreserved_keywordContext) LARGE_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserLARGE_P, 0)
}

func (s *Unreserved_keywordContext) LAST_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserLAST_P, 0)
}

func (s *Unreserved_keywordContext) LEAKPROOF() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserLEAKPROOF, 0)
}

func (s *Unreserved_keywordContext) LEVEL() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserLEVEL, 0)
}

func (s *Unreserved_keywordContext) LISTEN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserLISTEN, 0)
}

func (s *Unreserved_keywordContext) LOAD() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserLOAD, 0)
}

func (s *Unreserved_keywordContext) LOCAL() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserLOCAL, 0)
}

func (s *Unreserved_keywordContext) LOCATION() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserLOCATION, 0)
}

func (s *Unreserved_keywordContext) LOCK_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserLOCK_P, 0)
}

func (s *Unreserved_keywordContext) LOCKED() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserLOCKED, 0)
}

func (s *Unreserved_keywordContext) LOGGED() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserLOGGED, 0)
}

func (s *Unreserved_keywordContext) MAPPING() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserMAPPING, 0)
}

func (s *Unreserved_keywordContext) MATCH() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserMATCH, 0)
}

func (s *Unreserved_keywordContext) MATERIALIZED() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserMATERIALIZED, 0)
}

func (s *Unreserved_keywordContext) MAXVALUE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserMAXVALUE, 0)
}

func (s *Unreserved_keywordContext) METHOD() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserMETHOD, 0)
}

func (s *Unreserved_keywordContext) MINUTE_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserMINUTE_P, 0)
}

func (s *Unreserved_keywordContext) MINVALUE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserMINVALUE, 0)
}

func (s *Unreserved_keywordContext) MODE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserMODE, 0)
}

func (s *Unreserved_keywordContext) MONTH_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserMONTH_P, 0)
}

func (s *Unreserved_keywordContext) MOVE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserMOVE, 0)
}

func (s *Unreserved_keywordContext) NAME_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserNAME_P, 0)
}

func (s *Unreserved_keywordContext) NAMES() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserNAMES, 0)
}

func (s *Unreserved_keywordContext) NEW() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserNEW, 0)
}

func (s *Unreserved_keywordContext) NEXT() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserNEXT, 0)
}

func (s *Unreserved_keywordContext) NFC() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserNFC, 0)
}

func (s *Unreserved_keywordContext) NFD() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserNFD, 0)
}

func (s *Unreserved_keywordContext) NFKC() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserNFKC, 0)
}

func (s *Unreserved_keywordContext) NFKD() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserNFKD, 0)
}

func (s *Unreserved_keywordContext) NO() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserNO, 0)
}

func (s *Unreserved_keywordContext) NORMALIZED() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserNORMALIZED, 0)
}

func (s *Unreserved_keywordContext) NOTHING() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserNOTHING, 0)
}

func (s *Unreserved_keywordContext) NOTIFY() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserNOTIFY, 0)
}

func (s *Unreserved_keywordContext) NOWAIT() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserNOWAIT, 0)
}

func (s *Unreserved_keywordContext) NULLS_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserNULLS_P, 0)
}

func (s *Unreserved_keywordContext) OBJECT_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserOBJECT_P, 0)
}

func (s *Unreserved_keywordContext) OF() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserOF, 0)
}

func (s *Unreserved_keywordContext) OFF() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserOFF, 0)
}

func (s *Unreserved_keywordContext) OIDS() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserOIDS, 0)
}

func (s *Unreserved_keywordContext) OLD() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserOLD, 0)
}

func (s *Unreserved_keywordContext) OPERATOR() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserOPERATOR, 0)
}

func (s *Unreserved_keywordContext) OPTION() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserOPTION, 0)
}

func (s *Unreserved_keywordContext) OPTIONS() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserOPTIONS, 0)
}

func (s *Unreserved_keywordContext) ORDINALITY() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserORDINALITY, 0)
}

func (s *Unreserved_keywordContext) OTHERS() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserOTHERS, 0)
}

func (s *Unreserved_keywordContext) OVER() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserOVER, 0)
}

func (s *Unreserved_keywordContext) OVERRIDING() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserOVERRIDING, 0)
}

func (s *Unreserved_keywordContext) OWNED() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserOWNED, 0)
}

func (s *Unreserved_keywordContext) OWNER() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserOWNER, 0)
}

func (s *Unreserved_keywordContext) PARALLEL() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserPARALLEL, 0)
}

func (s *Unreserved_keywordContext) PARSER() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserPARSER, 0)
}

func (s *Unreserved_keywordContext) PARTIAL() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserPARTIAL, 0)
}

func (s *Unreserved_keywordContext) PARTITION() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserPARTITION, 0)
}

func (s *Unreserved_keywordContext) PASSING() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserPASSING, 0)
}

func (s *Unreserved_keywordContext) PASSWORD() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserPASSWORD, 0)
}

func (s *Unreserved_keywordContext) PLANS() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserPLANS, 0)
}

func (s *Unreserved_keywordContext) POLICY() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserPOLICY, 0)
}

func (s *Unreserved_keywordContext) PRECEDING() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserPRECEDING, 0)
}

func (s *Unreserved_keywordContext) PREPARE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserPREPARE, 0)
}

func (s *Unreserved_keywordContext) PREPARED() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserPREPARED, 0)
}

func (s *Unreserved_keywordContext) PRESERVE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserPRESERVE, 0)
}

func (s *Unreserved_keywordContext) PRIOR() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserPRIOR, 0)
}

func (s *Unreserved_keywordContext) PRIVILEGES() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserPRIVILEGES, 0)
}

func (s *Unreserved_keywordContext) PROCEDURAL() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserPROCEDURAL, 0)
}

func (s *Unreserved_keywordContext) PROCEDURE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserPROCEDURE, 0)
}

func (s *Unreserved_keywordContext) PROCEDURES() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserPROCEDURES, 0)
}

func (s *Unreserved_keywordContext) PROGRAM() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserPROGRAM, 0)
}

func (s *Unreserved_keywordContext) PUBLICATION() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserPUBLICATION, 0)
}

func (s *Unreserved_keywordContext) QUOTE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserQUOTE, 0)
}

func (s *Unreserved_keywordContext) RANGE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserRANGE, 0)
}

func (s *Unreserved_keywordContext) READ() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserREAD, 0)
}

func (s *Unreserved_keywordContext) REASSIGN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserREASSIGN, 0)
}

func (s *Unreserved_keywordContext) RECHECK() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserRECHECK, 0)
}

func (s *Unreserved_keywordContext) RECURSIVE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserRECURSIVE, 0)
}

func (s *Unreserved_keywordContext) REF() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserREF, 0)
}

func (s *Unreserved_keywordContext) REFERENCING() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserREFERENCING, 0)
}

func (s *Unreserved_keywordContext) REFRESH() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserREFRESH, 0)
}

func (s *Unreserved_keywordContext) REINDEX() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserREINDEX, 0)
}

func (s *Unreserved_keywordContext) RELATIVE_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserRELATIVE_P, 0)
}

func (s *Unreserved_keywordContext) RELEASE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserRELEASE, 0)
}

func (s *Unreserved_keywordContext) RENAME() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserRENAME, 0)
}

func (s *Unreserved_keywordContext) REPEATABLE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserREPEATABLE, 0)
}

func (s *Unreserved_keywordContext) REPLICA() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserREPLICA, 0)
}

func (s *Unreserved_keywordContext) RESET() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserRESET, 0)
}

func (s *Unreserved_keywordContext) RESTART() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserRESTART, 0)
}

func (s *Unreserved_keywordContext) RESTRICT() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserRESTRICT, 0)
}

func (s *Unreserved_keywordContext) RETURNS() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserRETURNS, 0)
}

func (s *Unreserved_keywordContext) REVOKE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserREVOKE, 0)
}

func (s *Unreserved_keywordContext) ROLE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserROLE, 0)
}

func (s *Unreserved_keywordContext) ROLLBACK() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserROLLBACK, 0)
}

func (s *Unreserved_keywordContext) ROLLUP() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserROLLUP, 0)
}

func (s *Unreserved_keywordContext) ROUTINE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserROUTINE, 0)
}

func (s *Unreserved_keywordContext) ROUTINES() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserROUTINES, 0)
}

func (s *Unreserved_keywordContext) ROWS() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserROWS, 0)
}

func (s *Unreserved_keywordContext) RULE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserRULE, 0)
}

func (s *Unreserved_keywordContext) SAVEPOINT() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserSAVEPOINT, 0)
}

func (s *Unreserved_keywordContext) SCHEMA() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserSCHEMA, 0)
}

func (s *Unreserved_keywordContext) SCHEMAS() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserSCHEMAS, 0)
}

func (s *Unreserved_keywordContext) SCROLL() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserSCROLL, 0)
}

func (s *Unreserved_keywordContext) SEARCH() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserSEARCH, 0)
}

func (s *Unreserved_keywordContext) SECOND_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserSECOND_P, 0)
}

func (s *Unreserved_keywordContext) SECURITY() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserSECURITY, 0)
}

func (s *Unreserved_keywordContext) SEQUENCE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserSEQUENCE, 0)
}

func (s *Unreserved_keywordContext) SEQUENCES() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserSEQUENCES, 0)
}

func (s *Unreserved_keywordContext) SERIALIZABLE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserSERIALIZABLE, 0)
}

func (s *Unreserved_keywordContext) SERVER() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserSERVER, 0)
}

func (s *Unreserved_keywordContext) SESSION() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserSESSION, 0)
}

func (s *Unreserved_keywordContext) SET() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserSET, 0)
}

func (s *Unreserved_keywordContext) SETS() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserSETS, 0)
}

func (s *Unreserved_keywordContext) SHARE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserSHARE, 0)
}

func (s *Unreserved_keywordContext) SHOW() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserSHOW, 0)
}

func (s *Unreserved_keywordContext) SIMPLE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserSIMPLE, 0)
}

func (s *Unreserved_keywordContext) SKIP_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserSKIP_P, 0)
}

func (s *Unreserved_keywordContext) SNAPSHOT() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserSNAPSHOT, 0)
}

func (s *Unreserved_keywordContext) SQL_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserSQL_P, 0)
}

func (s *Unreserved_keywordContext) STABLE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserSTABLE, 0)
}

func (s *Unreserved_keywordContext) STANDALONE_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserSTANDALONE_P, 0)
}

func (s *Unreserved_keywordContext) START() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserSTART, 0)
}

func (s *Unreserved_keywordContext) STATEMENT() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserSTATEMENT, 0)
}

func (s *Unreserved_keywordContext) STATISTICS() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserSTATISTICS, 0)
}

func (s *Unreserved_keywordContext) STDIN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserSTDIN, 0)
}

func (s *Unreserved_keywordContext) STDOUT() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserSTDOUT, 0)
}

func (s *Unreserved_keywordContext) STORAGE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserSTORAGE, 0)
}

func (s *Unreserved_keywordContext) STORED() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserSTORED, 0)
}

func (s *Unreserved_keywordContext) STRICT_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserSTRICT_P, 0)
}

func (s *Unreserved_keywordContext) STRIP_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserSTRIP_P, 0)
}

func (s *Unreserved_keywordContext) SUBSCRIPTION() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserSUBSCRIPTION, 0)
}

func (s *Unreserved_keywordContext) SUPPORT() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserSUPPORT, 0)
}

func (s *Unreserved_keywordContext) SYSID() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserSYSID, 0)
}

func (s *Unreserved_keywordContext) SYSTEM_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserSYSTEM_P, 0)
}

func (s *Unreserved_keywordContext) TABLES() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserTABLES, 0)
}

func (s *Unreserved_keywordContext) TABLESPACE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserTABLESPACE, 0)
}

func (s *Unreserved_keywordContext) TEMP() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserTEMP, 0)
}

func (s *Unreserved_keywordContext) TEMPLATE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserTEMPLATE, 0)
}

func (s *Unreserved_keywordContext) TEMPORARY() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserTEMPORARY, 0)
}

func (s *Unreserved_keywordContext) TEXT_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserTEXT_P, 0)
}

func (s *Unreserved_keywordContext) TIES() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserTIES, 0)
}

func (s *Unreserved_keywordContext) TRANSACTION() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserTRANSACTION, 0)
}

func (s *Unreserved_keywordContext) TRANSFORM() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserTRANSFORM, 0)
}

func (s *Unreserved_keywordContext) TRIGGER() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserTRIGGER, 0)
}

func (s *Unreserved_keywordContext) TRUNCATE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserTRUNCATE, 0)
}

func (s *Unreserved_keywordContext) TRUSTED() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserTRUSTED, 0)
}

func (s *Unreserved_keywordContext) TYPE_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserTYPE_P, 0)
}

func (s *Unreserved_keywordContext) TYPES_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserTYPES_P, 0)
}

func (s *Unreserved_keywordContext) UESCAPE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserUESCAPE, 0)
}

func (s *Unreserved_keywordContext) UNBOUNDED() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserUNBOUNDED, 0)
}

func (s *Unreserved_keywordContext) UNCOMMITTED() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserUNCOMMITTED, 0)
}

func (s *Unreserved_keywordContext) UNENCRYPTED() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserUNENCRYPTED, 0)
}

func (s *Unreserved_keywordContext) UNKNOWN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserUNKNOWN, 0)
}

func (s *Unreserved_keywordContext) UNLISTEN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserUNLISTEN, 0)
}

func (s *Unreserved_keywordContext) UNLOGGED() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserUNLOGGED, 0)
}

func (s *Unreserved_keywordContext) UNTIL() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserUNTIL, 0)
}

func (s *Unreserved_keywordContext) UPDATE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserUPDATE, 0)
}

func (s *Unreserved_keywordContext) VACUUM() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserVACUUM, 0)
}

func (s *Unreserved_keywordContext) VALID() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserVALID, 0)
}

func (s *Unreserved_keywordContext) VALIDATE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserVALIDATE, 0)
}

func (s *Unreserved_keywordContext) VALIDATOR() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserVALIDATOR, 0)
}

func (s *Unreserved_keywordContext) VALUE_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserVALUE_P, 0)
}

func (s *Unreserved_keywordContext) VARYING() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserVARYING, 0)
}

func (s *Unreserved_keywordContext) VERSION_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserVERSION_P, 0)
}

func (s *Unreserved_keywordContext) VIEW() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserVIEW, 0)
}

func (s *Unreserved_keywordContext) VIEWS() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserVIEWS, 0)
}

func (s *Unreserved_keywordContext) VOLATILE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserVOLATILE, 0)
}

func (s *Unreserved_keywordContext) WHITESPACE_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserWHITESPACE_P, 0)
}

func (s *Unreserved_keywordContext) WITHIN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserWITHIN, 0)
}

func (s *Unreserved_keywordContext) WITHOUT() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserWITHOUT, 0)
}

func (s *Unreserved_keywordContext) WORK() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserWORK, 0)
}

func (s *Unreserved_keywordContext) WRAPPER() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserWRAPPER, 0)
}

func (s *Unreserved_keywordContext) WRITE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserWRITE, 0)
}

func (s *Unreserved_keywordContext) XML_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserXML_P, 0)
}

func (s *Unreserved_keywordContext) YEAR_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserYEAR_P, 0)
}

func (s *Unreserved_keywordContext) YES_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserYES_P, 0)
}

func (s *Unreserved_keywordContext) ZONE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserZONE, 0)
}

func (s *Unreserved_keywordContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Unreserved_keywordContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Unreserved_keywordContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterUnreserved_keyword(s)
	}
}

func (s *Unreserved_keywordContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitUnreserved_keyword(s)
	}
}

func (s *Unreserved_keywordContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitUnreserved_keyword(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Unreserved_keyword() (localctx IUnreserved_keywordContext) {
	localctx = NewUnreserved_keywordContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1386, PostgreSQLParserRULE_unreserved_keyword)
	var _la int

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(9890)
		_la = p.GetTokenStream().LA(1)

		if !(((int64((_la-124)) & ^0x3f) == 0 && ((int64(1)<<(_la-124))&-31) != 0) || ((int64((_la-188)) & ^0x3f) == 0 && ((int64(1)<<(_la-188))&-4611686018427387905) != 0) || ((int64((_la-252)) & ^0x3f) == 0 && ((int64(1)<<(_la-252))&-4503599627370499) != 0) || ((int64((_la-316)) & ^0x3f) == 0 && ((int64(1)<<(_la-316))&-1) != 0) || ((int64((_la-433)) & ^0x3f) == 0 && ((int64(1)<<(_la-433))&72028319537692671) != 0)) {
			p.GetErrorHandler().RecoverInline(p)
		} else {
			p.GetErrorHandler().ReportMatch(p)
			p.Consume()
		}
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// ICol_name_keywordContext is an interface to support dynamic dispatch.
type ICol_name_keywordContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	BETWEEN() antlr.TerminalNode
	BIGINT() antlr.TerminalNode
	Bit() IBitContext
	BOOLEAN_P() antlr.TerminalNode
	CHAR_P() antlr.TerminalNode
	Character() ICharacterContext
	COALESCE() antlr.TerminalNode
	DEC() antlr.TerminalNode
	DECIMAL_P() antlr.TerminalNode
	EXISTS() antlr.TerminalNode
	EXTRACT() antlr.TerminalNode
	FLOAT_P() antlr.TerminalNode
	GREATEST() antlr.TerminalNode
	GROUPING() antlr.TerminalNode
	INOUT() antlr.TerminalNode
	INT_P() antlr.TerminalNode
	INTEGER() antlr.TerminalNode
	INTERVAL() antlr.TerminalNode
	LEAST() antlr.TerminalNode
	NATIONAL() antlr.TerminalNode
	NCHAR() antlr.TerminalNode
	NONE() antlr.TerminalNode
	NORMALIZE() antlr.TerminalNode
	NULLIF() antlr.TerminalNode
	Numeric() INumericContext
	OUT_P() antlr.TerminalNode
	OVERLAY() antlr.TerminalNode
	POSITION() antlr.TerminalNode
	PRECISION() antlr.TerminalNode
	REAL() antlr.TerminalNode
	ROW() antlr.TerminalNode
	SETOF() antlr.TerminalNode
	SMALLINT() antlr.TerminalNode
	SUBSTRING() antlr.TerminalNode
	TIME() antlr.TerminalNode
	TIMESTAMP() antlr.TerminalNode
	TREAT() antlr.TerminalNode
	TRIM() antlr.TerminalNode
	VALUES() antlr.TerminalNode
	VARCHAR() antlr.TerminalNode
	XMLATTRIBUTES() antlr.TerminalNode
	XMLCONCAT() antlr.TerminalNode
	XMLELEMENT() antlr.TerminalNode
	XMLEXISTS() antlr.TerminalNode
	XMLFOREST() antlr.TerminalNode
	XMLNAMESPACES() antlr.TerminalNode
	XMLPARSE() antlr.TerminalNode
	XMLPI() antlr.TerminalNode
	XMLROOT() antlr.TerminalNode
	XMLSERIALIZE() antlr.TerminalNode
	XMLTABLE() antlr.TerminalNode
	Builtin_function_name() IBuiltin_function_nameContext

	// IsCol_name_keywordContext differentiates from other interfaces.
	IsCol_name_keywordContext()
}

type Col_name_keywordContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyCol_name_keywordContext() *Col_name_keywordContext {
	var p = new(Col_name_keywordContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_col_name_keyword
	return p
}

func InitEmptyCol_name_keywordContext(p *Col_name_keywordContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_col_name_keyword
}

func (*Col_name_keywordContext) IsCol_name_keywordContext() {}

func NewCol_name_keywordContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Col_name_keywordContext {
	var p = new(Col_name_keywordContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_col_name_keyword

	return p
}

func (s *Col_name_keywordContext) GetParser() antlr.Parser { return s.parser }

func (s *Col_name_keywordContext) BETWEEN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserBETWEEN, 0)
}

func (s *Col_name_keywordContext) BIGINT() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserBIGINT, 0)
}

func (s *Col_name_keywordContext) Bit() IBitContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IBitContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IBitContext)
}

func (s *Col_name_keywordContext) BOOLEAN_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserBOOLEAN_P, 0)
}

func (s *Col_name_keywordContext) CHAR_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCHAR_P, 0)
}

func (s *Col_name_keywordContext) Character() ICharacterContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ICharacterContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ICharacterContext)
}

func (s *Col_name_keywordContext) COALESCE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCOALESCE, 0)
}

func (s *Col_name_keywordContext) DEC() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserDEC, 0)
}

func (s *Col_name_keywordContext) DECIMAL_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserDECIMAL_P, 0)
}

func (s *Col_name_keywordContext) EXISTS() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserEXISTS, 0)
}

func (s *Col_name_keywordContext) EXTRACT() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserEXTRACT, 0)
}

func (s *Col_name_keywordContext) FLOAT_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserFLOAT_P, 0)
}

func (s *Col_name_keywordContext) GREATEST() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserGREATEST, 0)
}

func (s *Col_name_keywordContext) GROUPING() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserGROUPING, 0)
}

func (s *Col_name_keywordContext) INOUT() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserINOUT, 0)
}

func (s *Col_name_keywordContext) INT_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserINT_P, 0)
}

func (s *Col_name_keywordContext) INTEGER() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserINTEGER, 0)
}

func (s *Col_name_keywordContext) INTERVAL() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserINTERVAL, 0)
}

func (s *Col_name_keywordContext) LEAST() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserLEAST, 0)
}

func (s *Col_name_keywordContext) NATIONAL() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserNATIONAL, 0)
}

func (s *Col_name_keywordContext) NCHAR() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserNCHAR, 0)
}

func (s *Col_name_keywordContext) NONE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserNONE, 0)
}

func (s *Col_name_keywordContext) NORMALIZE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserNORMALIZE, 0)
}

func (s *Col_name_keywordContext) NULLIF() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserNULLIF, 0)
}

func (s *Col_name_keywordContext) Numeric() INumericContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(INumericContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(INumericContext)
}

func (s *Col_name_keywordContext) OUT_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserOUT_P, 0)
}

func (s *Col_name_keywordContext) OVERLAY() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserOVERLAY, 0)
}

func (s *Col_name_keywordContext) POSITION() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserPOSITION, 0)
}

func (s *Col_name_keywordContext) PRECISION() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserPRECISION, 0)
}

func (s *Col_name_keywordContext) REAL() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserREAL, 0)
}

func (s *Col_name_keywordContext) ROW() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserROW, 0)
}

func (s *Col_name_keywordContext) SETOF() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserSETOF, 0)
}

func (s *Col_name_keywordContext) SMALLINT() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserSMALLINT, 0)
}

func (s *Col_name_keywordContext) SUBSTRING() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserSUBSTRING, 0)
}

func (s *Col_name_keywordContext) TIME() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserTIME, 0)
}

func (s *Col_name_keywordContext) TIMESTAMP() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserTIMESTAMP, 0)
}

func (s *Col_name_keywordContext) TREAT() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserTREAT, 0)
}

func (s *Col_name_keywordContext) TRIM() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserTRIM, 0)
}

func (s *Col_name_keywordContext) VALUES() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserVALUES, 0)
}

func (s *Col_name_keywordContext) VARCHAR() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserVARCHAR, 0)
}

func (s *Col_name_keywordContext) XMLATTRIBUTES() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserXMLATTRIBUTES, 0)
}

func (s *Col_name_keywordContext) XMLCONCAT() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserXMLCONCAT, 0)
}

func (s *Col_name_keywordContext) XMLELEMENT() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserXMLELEMENT, 0)
}

func (s *Col_name_keywordContext) XMLEXISTS() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserXMLEXISTS, 0)
}

func (s *Col_name_keywordContext) XMLFOREST() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserXMLFOREST, 0)
}

func (s *Col_name_keywordContext) XMLNAMESPACES() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserXMLNAMESPACES, 0)
}

func (s *Col_name_keywordContext) XMLPARSE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserXMLPARSE, 0)
}

func (s *Col_name_keywordContext) XMLPI() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserXMLPI, 0)
}

func (s *Col_name_keywordContext) XMLROOT() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserXMLROOT, 0)
}

func (s *Col_name_keywordContext) XMLSERIALIZE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserXMLSERIALIZE, 0)
}

func (s *Col_name_keywordContext) XMLTABLE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserXMLTABLE, 0)
}

func (s *Col_name_keywordContext) Builtin_function_name() IBuiltin_function_nameContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IBuiltin_function_nameContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IBuiltin_function_nameContext)
}

func (s *Col_name_keywordContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Col_name_keywordContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Col_name_keywordContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterCol_name_keyword(s)
	}
}

func (s *Col_name_keywordContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitCol_name_keyword(s)
	}
}

func (s *Col_name_keywordContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitCol_name_keyword(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Col_name_keyword() (localctx ICol_name_keywordContext) {
	localctx = NewCol_name_keywordContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1388, PostgreSQLParserRULE_col_name_keyword)
	p.SetState(9944)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 664, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(9892)
			p.Match(PostgreSQLParserBETWEEN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(9893)
			p.Match(PostgreSQLParserBIGINT)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 3:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(9894)
			p.Bit()
		}

	case 4:
		p.EnterOuterAlt(localctx, 4)
		{
			p.SetState(9895)
			p.Match(PostgreSQLParserBOOLEAN_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 5:
		p.EnterOuterAlt(localctx, 5)
		{
			p.SetState(9896)
			p.Match(PostgreSQLParserCHAR_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 6:
		p.EnterOuterAlt(localctx, 6)
		{
			p.SetState(9897)
			p.Character()
		}

	case 7:
		p.EnterOuterAlt(localctx, 7)
		{
			p.SetState(9898)
			p.Match(PostgreSQLParserCOALESCE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 8:
		p.EnterOuterAlt(localctx, 8)
		{
			p.SetState(9899)
			p.Match(PostgreSQLParserDEC)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 9:
		p.EnterOuterAlt(localctx, 9)
		{
			p.SetState(9900)
			p.Match(PostgreSQLParserDECIMAL_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 10:
		p.EnterOuterAlt(localctx, 10)
		{
			p.SetState(9901)
			p.Match(PostgreSQLParserEXISTS)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 11:
		p.EnterOuterAlt(localctx, 11)
		{
			p.SetState(9902)
			p.Match(PostgreSQLParserEXTRACT)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 12:
		p.EnterOuterAlt(localctx, 12)
		{
			p.SetState(9903)
			p.Match(PostgreSQLParserFLOAT_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 13:
		p.EnterOuterAlt(localctx, 13)
		{
			p.SetState(9904)
			p.Match(PostgreSQLParserGREATEST)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 14:
		p.EnterOuterAlt(localctx, 14)
		{
			p.SetState(9905)
			p.Match(PostgreSQLParserGROUPING)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 15:
		p.EnterOuterAlt(localctx, 15)
		{
			p.SetState(9906)
			p.Match(PostgreSQLParserINOUT)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 16:
		p.EnterOuterAlt(localctx, 16)
		{
			p.SetState(9907)
			p.Match(PostgreSQLParserINT_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 17:
		p.EnterOuterAlt(localctx, 17)
		{
			p.SetState(9908)
			p.Match(PostgreSQLParserINTEGER)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 18:
		p.EnterOuterAlt(localctx, 18)
		{
			p.SetState(9909)
			p.Match(PostgreSQLParserINTERVAL)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 19:
		p.EnterOuterAlt(localctx, 19)
		{
			p.SetState(9910)
			p.Match(PostgreSQLParserLEAST)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 20:
		p.EnterOuterAlt(localctx, 20)
		{
			p.SetState(9911)
			p.Match(PostgreSQLParserNATIONAL)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 21:
		p.EnterOuterAlt(localctx, 21)
		{
			p.SetState(9912)
			p.Match(PostgreSQLParserNCHAR)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 22:
		p.EnterOuterAlt(localctx, 22)
		{
			p.SetState(9913)
			p.Match(PostgreSQLParserNONE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 23:
		p.EnterOuterAlt(localctx, 23)
		{
			p.SetState(9914)
			p.Match(PostgreSQLParserNORMALIZE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 24:
		p.EnterOuterAlt(localctx, 24)
		{
			p.SetState(9915)
			p.Match(PostgreSQLParserNULLIF)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 25:
		p.EnterOuterAlt(localctx, 25)
		{
			p.SetState(9916)
			p.Numeric()
		}

	case 26:
		p.EnterOuterAlt(localctx, 26)
		{
			p.SetState(9917)
			p.Match(PostgreSQLParserOUT_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 27:
		p.EnterOuterAlt(localctx, 27)
		{
			p.SetState(9918)
			p.Match(PostgreSQLParserOVERLAY)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 28:
		p.EnterOuterAlt(localctx, 28)
		{
			p.SetState(9919)
			p.Match(PostgreSQLParserPOSITION)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 29:
		p.EnterOuterAlt(localctx, 29)
		{
			p.SetState(9920)
			p.Match(PostgreSQLParserPRECISION)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 30:
		p.EnterOuterAlt(localctx, 30)
		{
			p.SetState(9921)
			p.Match(PostgreSQLParserREAL)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 31:
		p.EnterOuterAlt(localctx, 31)
		{
			p.SetState(9922)
			p.Match(PostgreSQLParserROW)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 32:
		p.EnterOuterAlt(localctx, 32)
		{
			p.SetState(9923)
			p.Match(PostgreSQLParserSETOF)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 33:
		p.EnterOuterAlt(localctx, 33)
		{
			p.SetState(9924)
			p.Match(PostgreSQLParserSMALLINT)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 34:
		p.EnterOuterAlt(localctx, 34)
		{
			p.SetState(9925)
			p.Match(PostgreSQLParserSUBSTRING)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 35:
		p.EnterOuterAlt(localctx, 35)
		{
			p.SetState(9926)
			p.Match(PostgreSQLParserTIME)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 36:
		p.EnterOuterAlt(localctx, 36)
		{
			p.SetState(9927)
			p.Match(PostgreSQLParserTIMESTAMP)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 37:
		p.EnterOuterAlt(localctx, 37)
		{
			p.SetState(9928)
			p.Match(PostgreSQLParserTREAT)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 38:
		p.EnterOuterAlt(localctx, 38)
		{
			p.SetState(9929)
			p.Match(PostgreSQLParserTRIM)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 39:
		p.EnterOuterAlt(localctx, 39)
		{
			p.SetState(9930)
			p.Match(PostgreSQLParserVALUES)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 40:
		p.EnterOuterAlt(localctx, 40)
		{
			p.SetState(9931)
			p.Match(PostgreSQLParserVARCHAR)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 41:
		p.EnterOuterAlt(localctx, 41)
		{
			p.SetState(9932)
			p.Match(PostgreSQLParserXMLATTRIBUTES)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 42:
		p.EnterOuterAlt(localctx, 42)
		{
			p.SetState(9933)
			p.Match(PostgreSQLParserXMLCONCAT)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 43:
		p.EnterOuterAlt(localctx, 43)
		{
			p.SetState(9934)
			p.Match(PostgreSQLParserXMLELEMENT)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 44:
		p.EnterOuterAlt(localctx, 44)
		{
			p.SetState(9935)
			p.Match(PostgreSQLParserXMLEXISTS)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 45:
		p.EnterOuterAlt(localctx, 45)
		{
			p.SetState(9936)
			p.Match(PostgreSQLParserXMLFOREST)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 46:
		p.EnterOuterAlt(localctx, 46)
		{
			p.SetState(9937)
			p.Match(PostgreSQLParserXMLNAMESPACES)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 47:
		p.EnterOuterAlt(localctx, 47)
		{
			p.SetState(9938)
			p.Match(PostgreSQLParserXMLPARSE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 48:
		p.EnterOuterAlt(localctx, 48)
		{
			p.SetState(9939)
			p.Match(PostgreSQLParserXMLPI)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 49:
		p.EnterOuterAlt(localctx, 49)
		{
			p.SetState(9940)
			p.Match(PostgreSQLParserXMLROOT)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 50:
		p.EnterOuterAlt(localctx, 50)
		{
			p.SetState(9941)
			p.Match(PostgreSQLParserXMLSERIALIZE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 51:
		p.EnterOuterAlt(localctx, 51)
		{
			p.SetState(9942)
			p.Match(PostgreSQLParserXMLTABLE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 52:
		p.EnterOuterAlt(localctx, 52)
		{
			p.SetState(9943)
			p.Builtin_function_name()
		}

	case antlr.ATNInvalidAltNumber:
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IType_func_name_keywordContext is an interface to support dynamic dispatch.
type IType_func_name_keywordContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	AUTHORIZATION() antlr.TerminalNode
	BINARY() antlr.TerminalNode
	COLLATION() antlr.TerminalNode
	CONCURRENTLY() antlr.TerminalNode
	CROSS() antlr.TerminalNode
	CURRENT_SCHEMA() antlr.TerminalNode
	FREEZE() antlr.TerminalNode
	FULL() antlr.TerminalNode
	ILIKE() antlr.TerminalNode
	INNER_P() antlr.TerminalNode
	IS() antlr.TerminalNode
	ISNULL() antlr.TerminalNode
	JOIN() antlr.TerminalNode
	LIKE() antlr.TerminalNode
	NATURAL() antlr.TerminalNode
	NOTNULL() antlr.TerminalNode
	OUTER_P() antlr.TerminalNode
	OVERLAPS() antlr.TerminalNode
	SIMILAR() antlr.TerminalNode
	TABLESAMPLE() antlr.TerminalNode
	VERBOSE() antlr.TerminalNode

	// IsType_func_name_keywordContext differentiates from other interfaces.
	IsType_func_name_keywordContext()
}

type Type_func_name_keywordContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyType_func_name_keywordContext() *Type_func_name_keywordContext {
	var p = new(Type_func_name_keywordContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_type_func_name_keyword
	return p
}

func InitEmptyType_func_name_keywordContext(p *Type_func_name_keywordContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_type_func_name_keyword
}

func (*Type_func_name_keywordContext) IsType_func_name_keywordContext() {}

func NewType_func_name_keywordContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Type_func_name_keywordContext {
	var p = new(Type_func_name_keywordContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_type_func_name_keyword

	return p
}

func (s *Type_func_name_keywordContext) GetParser() antlr.Parser { return s.parser }

func (s *Type_func_name_keywordContext) AUTHORIZATION() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserAUTHORIZATION, 0)
}

func (s *Type_func_name_keywordContext) BINARY() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserBINARY, 0)
}

func (s *Type_func_name_keywordContext) COLLATION() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCOLLATION, 0)
}

func (s *Type_func_name_keywordContext) CONCURRENTLY() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCONCURRENTLY, 0)
}

func (s *Type_func_name_keywordContext) CROSS() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCROSS, 0)
}

func (s *Type_func_name_keywordContext) CURRENT_SCHEMA() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCURRENT_SCHEMA, 0)
}

func (s *Type_func_name_keywordContext) FREEZE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserFREEZE, 0)
}

func (s *Type_func_name_keywordContext) FULL() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserFULL, 0)
}

func (s *Type_func_name_keywordContext) ILIKE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserILIKE, 0)
}

func (s *Type_func_name_keywordContext) INNER_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserINNER_P, 0)
}

func (s *Type_func_name_keywordContext) IS() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserIS, 0)
}

func (s *Type_func_name_keywordContext) ISNULL() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserISNULL, 0)
}

func (s *Type_func_name_keywordContext) JOIN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserJOIN, 0)
}

func (s *Type_func_name_keywordContext) LIKE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserLIKE, 0)
}

func (s *Type_func_name_keywordContext) NATURAL() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserNATURAL, 0)
}

func (s *Type_func_name_keywordContext) NOTNULL() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserNOTNULL, 0)
}

func (s *Type_func_name_keywordContext) OUTER_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserOUTER_P, 0)
}

func (s *Type_func_name_keywordContext) OVERLAPS() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserOVERLAPS, 0)
}

func (s *Type_func_name_keywordContext) SIMILAR() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserSIMILAR, 0)
}

func (s *Type_func_name_keywordContext) TABLESAMPLE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserTABLESAMPLE, 0)
}

func (s *Type_func_name_keywordContext) VERBOSE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserVERBOSE, 0)
}

func (s *Type_func_name_keywordContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Type_func_name_keywordContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Type_func_name_keywordContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterType_func_name_keyword(s)
	}
}

func (s *Type_func_name_keywordContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitType_func_name_keyword(s)
	}
}

func (s *Type_func_name_keywordContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitType_func_name_keyword(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Type_func_name_keyword() (localctx IType_func_name_keywordContext) {
	localctx = NewType_func_name_keywordContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1390, PostgreSQLParserRULE_type_func_name_keyword)
	var _la int

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(9946)
		_la = p.GetTokenStream().LA(1)

		if !(((int64((_la-106)) & ^0x3f) == 0 && ((int64(1)<<(_la-106))&7069695) != 0) || _la == PostgreSQLParserTABLESAMPLE) {
			p.GetErrorHandler().RecoverInline(p)
		} else {
			p.GetErrorHandler().ReportMatch(p)
			p.Consume()
		}
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IReserved_keywordContext is an interface to support dynamic dispatch.
type IReserved_keywordContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	ALL() antlr.TerminalNode
	ANALYSE() antlr.TerminalNode
	ANALYZE() antlr.TerminalNode
	AND() antlr.TerminalNode
	ANY() antlr.TerminalNode
	ARRAY() antlr.TerminalNode
	AS() antlr.TerminalNode
	ASC() antlr.TerminalNode
	ASYMMETRIC() antlr.TerminalNode
	BOTH() antlr.TerminalNode
	CASE() antlr.TerminalNode
	CAST() antlr.TerminalNode
	CHECK() antlr.TerminalNode
	COLLATE() antlr.TerminalNode
	COLUMN() antlr.TerminalNode
	CONSTRAINT() antlr.TerminalNode
	CREATE() antlr.TerminalNode
	CURRENT_CATALOG() antlr.TerminalNode
	CURRENT_DATE() antlr.TerminalNode
	CURRENT_ROLE() antlr.TerminalNode
	CURRENT_TIME() antlr.TerminalNode
	CURRENT_TIMESTAMP() antlr.TerminalNode
	CURRENT_USER() antlr.TerminalNode
	DEFERRABLE() antlr.TerminalNode
	DESC() antlr.TerminalNode
	DISTINCT() antlr.TerminalNode
	DO() antlr.TerminalNode
	ELSE() antlr.TerminalNode
	END_P() antlr.TerminalNode
	EXCEPT() antlr.TerminalNode
	FALSE_P() antlr.TerminalNode
	FETCH() antlr.TerminalNode
	FOR() antlr.TerminalNode
	FOREIGN() antlr.TerminalNode
	FROM() antlr.TerminalNode
	GRANT() antlr.TerminalNode
	GROUP_P() antlr.TerminalNode
	HAVING() antlr.TerminalNode
	IN_P() antlr.TerminalNode
	INITIALLY() antlr.TerminalNode
	INTERSECT() antlr.TerminalNode
	LATERAL_P() antlr.TerminalNode
	LEADING() antlr.TerminalNode
	LIMIT() antlr.TerminalNode
	LOCALTIME() antlr.TerminalNode
	LOCALTIMESTAMP() antlr.TerminalNode
	NOT() antlr.TerminalNode
	NULL_P() antlr.TerminalNode
	OFFSET() antlr.TerminalNode
	ON() antlr.TerminalNode
	ONLY() antlr.TerminalNode
	OR() antlr.TerminalNode
	ORDER() antlr.TerminalNode
	PLACING() antlr.TerminalNode
	PRIMARY() antlr.TerminalNode
	REFERENCES() antlr.TerminalNode
	RETURNING() antlr.TerminalNode
	SELECT() antlr.TerminalNode
	SESSION_USER() antlr.TerminalNode
	SOME() antlr.TerminalNode
	SYMMETRIC() antlr.TerminalNode
	TABLE() antlr.TerminalNode
	THEN() antlr.TerminalNode
	TO() antlr.TerminalNode
	TRAILING() antlr.TerminalNode
	TRUE_P() antlr.TerminalNode
	UNION() antlr.TerminalNode
	UNIQUE() antlr.TerminalNode
	USER() antlr.TerminalNode
	USING() antlr.TerminalNode
	VARIADIC() antlr.TerminalNode
	WHEN() antlr.TerminalNode
	WHERE() antlr.TerminalNode
	WINDOW() antlr.TerminalNode
	WITH() antlr.TerminalNode

	// IsReserved_keywordContext differentiates from other interfaces.
	IsReserved_keywordContext()
}

type Reserved_keywordContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyReserved_keywordContext() *Reserved_keywordContext {
	var p = new(Reserved_keywordContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_reserved_keyword
	return p
}

func InitEmptyReserved_keywordContext(p *Reserved_keywordContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_reserved_keyword
}

func (*Reserved_keywordContext) IsReserved_keywordContext() {}

func NewReserved_keywordContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Reserved_keywordContext {
	var p = new(Reserved_keywordContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_reserved_keyword

	return p
}

func (s *Reserved_keywordContext) GetParser() antlr.Parser { return s.parser }

func (s *Reserved_keywordContext) ALL() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserALL, 0)
}

func (s *Reserved_keywordContext) ANALYSE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserANALYSE, 0)
}

func (s *Reserved_keywordContext) ANALYZE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserANALYZE, 0)
}

func (s *Reserved_keywordContext) AND() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserAND, 0)
}

func (s *Reserved_keywordContext) ANY() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserANY, 0)
}

func (s *Reserved_keywordContext) ARRAY() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserARRAY, 0)
}

func (s *Reserved_keywordContext) AS() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserAS, 0)
}

func (s *Reserved_keywordContext) ASC() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserASC, 0)
}

func (s *Reserved_keywordContext) ASYMMETRIC() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserASYMMETRIC, 0)
}

func (s *Reserved_keywordContext) BOTH() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserBOTH, 0)
}

func (s *Reserved_keywordContext) CASE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCASE, 0)
}

func (s *Reserved_keywordContext) CAST() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCAST, 0)
}

func (s *Reserved_keywordContext) CHECK() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCHECK, 0)
}

func (s *Reserved_keywordContext) COLLATE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCOLLATE, 0)
}

func (s *Reserved_keywordContext) COLUMN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCOLUMN, 0)
}

func (s *Reserved_keywordContext) CONSTRAINT() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCONSTRAINT, 0)
}

func (s *Reserved_keywordContext) CREATE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCREATE, 0)
}

func (s *Reserved_keywordContext) CURRENT_CATALOG() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCURRENT_CATALOG, 0)
}

func (s *Reserved_keywordContext) CURRENT_DATE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCURRENT_DATE, 0)
}

func (s *Reserved_keywordContext) CURRENT_ROLE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCURRENT_ROLE, 0)
}

func (s *Reserved_keywordContext) CURRENT_TIME() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCURRENT_TIME, 0)
}

func (s *Reserved_keywordContext) CURRENT_TIMESTAMP() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCURRENT_TIMESTAMP, 0)
}

func (s *Reserved_keywordContext) CURRENT_USER() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCURRENT_USER, 0)
}

func (s *Reserved_keywordContext) DEFERRABLE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserDEFERRABLE, 0)
}

func (s *Reserved_keywordContext) DESC() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserDESC, 0)
}

func (s *Reserved_keywordContext) DISTINCT() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserDISTINCT, 0)
}

func (s *Reserved_keywordContext) DO() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserDO, 0)
}

func (s *Reserved_keywordContext) ELSE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserELSE, 0)
}

func (s *Reserved_keywordContext) END_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserEND_P, 0)
}

func (s *Reserved_keywordContext) EXCEPT() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserEXCEPT, 0)
}

func (s *Reserved_keywordContext) FALSE_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserFALSE_P, 0)
}

func (s *Reserved_keywordContext) FETCH() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserFETCH, 0)
}

func (s *Reserved_keywordContext) FOR() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserFOR, 0)
}

func (s *Reserved_keywordContext) FOREIGN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserFOREIGN, 0)
}

func (s *Reserved_keywordContext) FROM() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserFROM, 0)
}

func (s *Reserved_keywordContext) GRANT() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserGRANT, 0)
}

func (s *Reserved_keywordContext) GROUP_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserGROUP_P, 0)
}

func (s *Reserved_keywordContext) HAVING() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserHAVING, 0)
}

func (s *Reserved_keywordContext) IN_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserIN_P, 0)
}

func (s *Reserved_keywordContext) INITIALLY() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserINITIALLY, 0)
}

func (s *Reserved_keywordContext) INTERSECT() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserINTERSECT, 0)
}

func (s *Reserved_keywordContext) LATERAL_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserLATERAL_P, 0)
}

func (s *Reserved_keywordContext) LEADING() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserLEADING, 0)
}

func (s *Reserved_keywordContext) LIMIT() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserLIMIT, 0)
}

func (s *Reserved_keywordContext) LOCALTIME() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserLOCALTIME, 0)
}

func (s *Reserved_keywordContext) LOCALTIMESTAMP() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserLOCALTIMESTAMP, 0)
}

func (s *Reserved_keywordContext) NOT() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserNOT, 0)
}

func (s *Reserved_keywordContext) NULL_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserNULL_P, 0)
}

func (s *Reserved_keywordContext) OFFSET() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserOFFSET, 0)
}

func (s *Reserved_keywordContext) ON() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserON, 0)
}

func (s *Reserved_keywordContext) ONLY() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserONLY, 0)
}

func (s *Reserved_keywordContext) OR() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserOR, 0)
}

func (s *Reserved_keywordContext) ORDER() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserORDER, 0)
}

func (s *Reserved_keywordContext) PLACING() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserPLACING, 0)
}

func (s *Reserved_keywordContext) PRIMARY() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserPRIMARY, 0)
}

func (s *Reserved_keywordContext) REFERENCES() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserREFERENCES, 0)
}

func (s *Reserved_keywordContext) RETURNING() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserRETURNING, 0)
}

func (s *Reserved_keywordContext) SELECT() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserSELECT, 0)
}

func (s *Reserved_keywordContext) SESSION_USER() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserSESSION_USER, 0)
}

func (s *Reserved_keywordContext) SOME() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserSOME, 0)
}

func (s *Reserved_keywordContext) SYMMETRIC() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserSYMMETRIC, 0)
}

func (s *Reserved_keywordContext) TABLE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserTABLE, 0)
}

func (s *Reserved_keywordContext) THEN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserTHEN, 0)
}

func (s *Reserved_keywordContext) TO() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserTO, 0)
}

func (s *Reserved_keywordContext) TRAILING() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserTRAILING, 0)
}

func (s *Reserved_keywordContext) TRUE_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserTRUE_P, 0)
}

func (s *Reserved_keywordContext) UNION() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserUNION, 0)
}

func (s *Reserved_keywordContext) UNIQUE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserUNIQUE, 0)
}

func (s *Reserved_keywordContext) USER() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserUSER, 0)
}

func (s *Reserved_keywordContext) USING() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserUSING, 0)
}

func (s *Reserved_keywordContext) VARIADIC() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserVARIADIC, 0)
}

func (s *Reserved_keywordContext) WHEN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserWHEN, 0)
}

func (s *Reserved_keywordContext) WHERE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserWHERE, 0)
}

func (s *Reserved_keywordContext) WINDOW() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserWINDOW, 0)
}

func (s *Reserved_keywordContext) WITH() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserWITH, 0)
}

func (s *Reserved_keywordContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Reserved_keywordContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Reserved_keywordContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterReserved_keyword(s)
	}
}

func (s *Reserved_keywordContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitReserved_keyword(s)
	}
}

func (s *Reserved_keywordContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitReserved_keyword(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Reserved_keyword() (localctx IReserved_keywordContext) {
	localctx = NewReserved_keywordContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1392, PostgreSQLParserRULE_reserved_keyword)
	var _la int

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(9948)
		_la = p.GetTokenStream().LA(1)

		if !(((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&-9007200328482816) != 0) || ((int64((_la-64)) & ^0x3f) == 0 && ((int64(1)<<(_la-64))&4398046510975) != 0) || _la == PostgreSQLParserEND_P) {
			p.GetErrorHandler().RecoverInline(p)
		} else {
			p.GetErrorHandler().ReportMatch(p)
			p.Consume()
		}
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IBuiltin_function_nameContext is an interface to support dynamic dispatch.
type IBuiltin_function_nameContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	XMLCOMMENT() antlr.TerminalNode
	XML_IS_WELL_FORMED() antlr.TerminalNode
	XML_IS_WELL_FORMED_DOCUMENT() antlr.TerminalNode
	XML_IS_WELL_FORMED_CONTENT() antlr.TerminalNode
	XMLAGG() antlr.TerminalNode
	XPATH() antlr.TerminalNode
	XPATH_EXISTS() antlr.TerminalNode
	ABS() antlr.TerminalNode
	CBRT() antlr.TerminalNode
	CEIL() antlr.TerminalNode
	CEILING() antlr.TerminalNode
	DEGREES() antlr.TerminalNode
	DIV() antlr.TerminalNode
	EXP() antlr.TerminalNode
	FACTORIAL() antlr.TerminalNode
	FLOOR() antlr.TerminalNode
	GCD() antlr.TerminalNode
	LCM() antlr.TerminalNode
	LN() antlr.TerminalNode
	LOG() antlr.TerminalNode
	LOG10() antlr.TerminalNode
	MIN_SCALE() antlr.TerminalNode
	MOD() antlr.TerminalNode
	PI() antlr.TerminalNode
	POWER() antlr.TerminalNode
	RADIANS() antlr.TerminalNode
	ROUND() antlr.TerminalNode
	SCALE() antlr.TerminalNode
	SIGN() antlr.TerminalNode
	SQRT() antlr.TerminalNode
	TRIM_SCALE() antlr.TerminalNode
	TRUNC() antlr.TerminalNode
	WIDTH_BUCKET() antlr.TerminalNode
	RANDOM() antlr.TerminalNode
	SETSEED() antlr.TerminalNode
	ACOS() antlr.TerminalNode
	ACOSD() antlr.TerminalNode
	ACOSH() antlr.TerminalNode
	ASIN() antlr.TerminalNode
	ASIND() antlr.TerminalNode
	ASINH() antlr.TerminalNode
	ATAN() antlr.TerminalNode
	ATAND() antlr.TerminalNode
	ATANH() antlr.TerminalNode
	ATAN2() antlr.TerminalNode
	ATAN2D() antlr.TerminalNode
	COS() antlr.TerminalNode
	COSD() antlr.TerminalNode
	COSH() antlr.TerminalNode
	COT() antlr.TerminalNode
	COTD() antlr.TerminalNode
	SIN() antlr.TerminalNode
	SIND() antlr.TerminalNode
	SINH() antlr.TerminalNode
	TAN() antlr.TerminalNode
	TAND() antlr.TerminalNode
	TANH() antlr.TerminalNode
	BIT_LENGTH() antlr.TerminalNode
	CHAR_LENGTH() antlr.TerminalNode
	CHARACTER_LENGTH() antlr.TerminalNode
	LOWER() antlr.TerminalNode
	OCTET_LENGTH() antlr.TerminalNode
	UPPER() antlr.TerminalNode
	ASCII() antlr.TerminalNode
	BTRIM() antlr.TerminalNode
	CHR() antlr.TerminalNode
	CONCAT() antlr.TerminalNode
	CONCAT_WS() antlr.TerminalNode
	FORMAT() antlr.TerminalNode
	INITCAP() antlr.TerminalNode
	LENGTH() antlr.TerminalNode
	LPAD() antlr.TerminalNode
	LTRIM() antlr.TerminalNode
	MD5() antlr.TerminalNode
	PARSE_IDENT() antlr.TerminalNode
	PG_CLIENT_ENCODING() antlr.TerminalNode
	QUOTE_IDENT() antlr.TerminalNode
	QUOTE_LITERAL() antlr.TerminalNode
	QUOTE_NULLABLE() antlr.TerminalNode
	REGEXP_COUNT() antlr.TerminalNode
	REGEXP_INSTR() antlr.TerminalNode
	REGEXP_LIKE() antlr.TerminalNode
	REGEXP_MATCH() antlr.TerminalNode
	REGEXP_MATCHES() antlr.TerminalNode
	REGEXP_REPLACE() antlr.TerminalNode
	REGEXP_SPLIT_TO_ARRAY() antlr.TerminalNode
	REGEXP_SPLIT_TO_TABLE() antlr.TerminalNode
	REGEXP_SUBSTR() antlr.TerminalNode
	REPEAT() antlr.TerminalNode
	REPLACE() antlr.TerminalNode
	REVERSE() antlr.TerminalNode
	RPAD() antlr.TerminalNode
	RTRIM() antlr.TerminalNode
	SPLIT_PART() antlr.TerminalNode
	STARTS_WITH() antlr.TerminalNode
	STRING_TO_ARRAY() antlr.TerminalNode
	STRING_TO_TABLE() antlr.TerminalNode
	STRPOS() antlr.TerminalNode
	SUBSTR() antlr.TerminalNode
	TO_ASCII() antlr.TerminalNode
	TO_HEX() antlr.TerminalNode
	TRANSLATE() antlr.TerminalNode
	UNISTR() antlr.TerminalNode
	AGE() antlr.TerminalNode
	DATE_BIN() antlr.TerminalNode
	DATE_PART() antlr.TerminalNode
	DATE_TRUNC() antlr.TerminalNode
	ISFINITE() antlr.TerminalNode
	JUSTIFY_DAYS() antlr.TerminalNode
	JUSTIFY_HOURS() antlr.TerminalNode
	JUSTIFY_INTERVAL() antlr.TerminalNode
	MAKE_DATE() antlr.TerminalNode
	MAKE_INTERVAL() antlr.TerminalNode
	MAKE_TIME() antlr.TerminalNode
	MAKE_TIMESTAMP() antlr.TerminalNode
	MAKE_TIMESTAMPTZ() antlr.TerminalNode
	CLOCK_TIMESTAMP() antlr.TerminalNode
	NOW() antlr.TerminalNode
	STATEMENT_TIMESTAMP() antlr.TerminalNode
	TIMEOFDAY() antlr.TerminalNode
	TRANSACTION_TIMESTAMP() antlr.TerminalNode
	TO_TIMESTAMP() antlr.TerminalNode
	TO_CHAR() antlr.TerminalNode
	TO_DATE() antlr.TerminalNode
	TO_NUMBER() antlr.TerminalNode

	// IsBuiltin_function_nameContext differentiates from other interfaces.
	IsBuiltin_function_nameContext()
}

type Builtin_function_nameContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyBuiltin_function_nameContext() *Builtin_function_nameContext {
	var p = new(Builtin_function_nameContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_builtin_function_name
	return p
}

func InitEmptyBuiltin_function_nameContext(p *Builtin_function_nameContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_builtin_function_name
}

func (*Builtin_function_nameContext) IsBuiltin_function_nameContext() {}

func NewBuiltin_function_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Builtin_function_nameContext {
	var p = new(Builtin_function_nameContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_builtin_function_name

	return p
}

func (s *Builtin_function_nameContext) GetParser() antlr.Parser { return s.parser }

func (s *Builtin_function_nameContext) XMLCOMMENT() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserXMLCOMMENT, 0)
}

func (s *Builtin_function_nameContext) XML_IS_WELL_FORMED() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserXML_IS_WELL_FORMED, 0)
}

func (s *Builtin_function_nameContext) XML_IS_WELL_FORMED_DOCUMENT() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserXML_IS_WELL_FORMED_DOCUMENT, 0)
}

func (s *Builtin_function_nameContext) XML_IS_WELL_FORMED_CONTENT() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserXML_IS_WELL_FORMED_CONTENT, 0)
}

func (s *Builtin_function_nameContext) XMLAGG() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserXMLAGG, 0)
}

func (s *Builtin_function_nameContext) XPATH() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserXPATH, 0)
}

func (s *Builtin_function_nameContext) XPATH_EXISTS() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserXPATH_EXISTS, 0)
}

func (s *Builtin_function_nameContext) ABS() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserABS, 0)
}

func (s *Builtin_function_nameContext) CBRT() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCBRT, 0)
}

func (s *Builtin_function_nameContext) CEIL() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCEIL, 0)
}

func (s *Builtin_function_nameContext) CEILING() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCEILING, 0)
}

func (s *Builtin_function_nameContext) DEGREES() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserDEGREES, 0)
}

func (s *Builtin_function_nameContext) DIV() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserDIV, 0)
}

func (s *Builtin_function_nameContext) EXP() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserEXP, 0)
}

func (s *Builtin_function_nameContext) FACTORIAL() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserFACTORIAL, 0)
}

func (s *Builtin_function_nameContext) FLOOR() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserFLOOR, 0)
}

func (s *Builtin_function_nameContext) GCD() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserGCD, 0)
}

func (s *Builtin_function_nameContext) LCM() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserLCM, 0)
}

func (s *Builtin_function_nameContext) LN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserLN, 0)
}

func (s *Builtin_function_nameContext) LOG() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserLOG, 0)
}

func (s *Builtin_function_nameContext) LOG10() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserLOG10, 0)
}

func (s *Builtin_function_nameContext) MIN_SCALE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserMIN_SCALE, 0)
}

func (s *Builtin_function_nameContext) MOD() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserMOD, 0)
}

func (s *Builtin_function_nameContext) PI() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserPI, 0)
}

func (s *Builtin_function_nameContext) POWER() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserPOWER, 0)
}

func (s *Builtin_function_nameContext) RADIANS() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserRADIANS, 0)
}

func (s *Builtin_function_nameContext) ROUND() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserROUND, 0)
}

func (s *Builtin_function_nameContext) SCALE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserSCALE, 0)
}

func (s *Builtin_function_nameContext) SIGN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserSIGN, 0)
}

func (s *Builtin_function_nameContext) SQRT() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserSQRT, 0)
}

func (s *Builtin_function_nameContext) TRIM_SCALE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserTRIM_SCALE, 0)
}

func (s *Builtin_function_nameContext) TRUNC() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserTRUNC, 0)
}

func (s *Builtin_function_nameContext) WIDTH_BUCKET() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserWIDTH_BUCKET, 0)
}

func (s *Builtin_function_nameContext) RANDOM() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserRANDOM, 0)
}

func (s *Builtin_function_nameContext) SETSEED() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserSETSEED, 0)
}

func (s *Builtin_function_nameContext) ACOS() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserACOS, 0)
}

func (s *Builtin_function_nameContext) ACOSD() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserACOSD, 0)
}

func (s *Builtin_function_nameContext) ACOSH() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserACOSH, 0)
}

func (s *Builtin_function_nameContext) ASIN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserASIN, 0)
}

func (s *Builtin_function_nameContext) ASIND() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserASIND, 0)
}

func (s *Builtin_function_nameContext) ASINH() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserASINH, 0)
}

func (s *Builtin_function_nameContext) ATAN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserATAN, 0)
}

func (s *Builtin_function_nameContext) ATAND() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserATAND, 0)
}

func (s *Builtin_function_nameContext) ATANH() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserATANH, 0)
}

func (s *Builtin_function_nameContext) ATAN2() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserATAN2, 0)
}

func (s *Builtin_function_nameContext) ATAN2D() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserATAN2D, 0)
}

func (s *Builtin_function_nameContext) COS() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCOS, 0)
}

func (s *Builtin_function_nameContext) COSD() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCOSD, 0)
}

func (s *Builtin_function_nameContext) COSH() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCOSH, 0)
}

func (s *Builtin_function_nameContext) COT() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCOT, 0)
}

func (s *Builtin_function_nameContext) COTD() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCOTD, 0)
}

func (s *Builtin_function_nameContext) SIN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserSIN, 0)
}

func (s *Builtin_function_nameContext) SIND() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserSIND, 0)
}

func (s *Builtin_function_nameContext) SINH() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserSINH, 0)
}

func (s *Builtin_function_nameContext) TAN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserTAN, 0)
}

func (s *Builtin_function_nameContext) TAND() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserTAND, 0)
}

func (s *Builtin_function_nameContext) TANH() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserTANH, 0)
}

func (s *Builtin_function_nameContext) BIT_LENGTH() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserBIT_LENGTH, 0)
}

func (s *Builtin_function_nameContext) CHAR_LENGTH() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCHAR_LENGTH, 0)
}

func (s *Builtin_function_nameContext) CHARACTER_LENGTH() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCHARACTER_LENGTH, 0)
}

func (s *Builtin_function_nameContext) LOWER() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserLOWER, 0)
}

func (s *Builtin_function_nameContext) OCTET_LENGTH() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserOCTET_LENGTH, 0)
}

func (s *Builtin_function_nameContext) UPPER() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserUPPER, 0)
}

func (s *Builtin_function_nameContext) ASCII() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserASCII, 0)
}

func (s *Builtin_function_nameContext) BTRIM() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserBTRIM, 0)
}

func (s *Builtin_function_nameContext) CHR() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCHR, 0)
}

func (s *Builtin_function_nameContext) CONCAT() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCONCAT, 0)
}

func (s *Builtin_function_nameContext) CONCAT_WS() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCONCAT_WS, 0)
}

func (s *Builtin_function_nameContext) FORMAT() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserFORMAT, 0)
}

func (s *Builtin_function_nameContext) INITCAP() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserINITCAP, 0)
}

func (s *Builtin_function_nameContext) LENGTH() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserLENGTH, 0)
}

func (s *Builtin_function_nameContext) LPAD() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserLPAD, 0)
}

func (s *Builtin_function_nameContext) LTRIM() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserLTRIM, 0)
}

func (s *Builtin_function_nameContext) MD5() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserMD5, 0)
}

func (s *Builtin_function_nameContext) PARSE_IDENT() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserPARSE_IDENT, 0)
}

func (s *Builtin_function_nameContext) PG_CLIENT_ENCODING() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserPG_CLIENT_ENCODING, 0)
}

func (s *Builtin_function_nameContext) QUOTE_IDENT() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserQUOTE_IDENT, 0)
}

func (s *Builtin_function_nameContext) QUOTE_LITERAL() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserQUOTE_LITERAL, 0)
}

func (s *Builtin_function_nameContext) QUOTE_NULLABLE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserQUOTE_NULLABLE, 0)
}

func (s *Builtin_function_nameContext) REGEXP_COUNT() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserREGEXP_COUNT, 0)
}

func (s *Builtin_function_nameContext) REGEXP_INSTR() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserREGEXP_INSTR, 0)
}

func (s *Builtin_function_nameContext) REGEXP_LIKE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserREGEXP_LIKE, 0)
}

func (s *Builtin_function_nameContext) REGEXP_MATCH() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserREGEXP_MATCH, 0)
}

func (s *Builtin_function_nameContext) REGEXP_MATCHES() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserREGEXP_MATCHES, 0)
}

func (s *Builtin_function_nameContext) REGEXP_REPLACE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserREGEXP_REPLACE, 0)
}

func (s *Builtin_function_nameContext) REGEXP_SPLIT_TO_ARRAY() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserREGEXP_SPLIT_TO_ARRAY, 0)
}

func (s *Builtin_function_nameContext) REGEXP_SPLIT_TO_TABLE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserREGEXP_SPLIT_TO_TABLE, 0)
}

func (s *Builtin_function_nameContext) REGEXP_SUBSTR() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserREGEXP_SUBSTR, 0)
}

func (s *Builtin_function_nameContext) REPEAT() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserREPEAT, 0)
}

func (s *Builtin_function_nameContext) REPLACE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserREPLACE, 0)
}

func (s *Builtin_function_nameContext) REVERSE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserREVERSE, 0)
}

func (s *Builtin_function_nameContext) RPAD() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserRPAD, 0)
}

func (s *Builtin_function_nameContext) RTRIM() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserRTRIM, 0)
}

func (s *Builtin_function_nameContext) SPLIT_PART() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserSPLIT_PART, 0)
}

func (s *Builtin_function_nameContext) STARTS_WITH() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserSTARTS_WITH, 0)
}

func (s *Builtin_function_nameContext) STRING_TO_ARRAY() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserSTRING_TO_ARRAY, 0)
}

func (s *Builtin_function_nameContext) STRING_TO_TABLE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserSTRING_TO_TABLE, 0)
}

func (s *Builtin_function_nameContext) STRPOS() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserSTRPOS, 0)
}

func (s *Builtin_function_nameContext) SUBSTR() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserSUBSTR, 0)
}

func (s *Builtin_function_nameContext) TO_ASCII() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserTO_ASCII, 0)
}

func (s *Builtin_function_nameContext) TO_HEX() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserTO_HEX, 0)
}

func (s *Builtin_function_nameContext) TRANSLATE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserTRANSLATE, 0)
}

func (s *Builtin_function_nameContext) UNISTR() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserUNISTR, 0)
}

func (s *Builtin_function_nameContext) AGE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserAGE, 0)
}

func (s *Builtin_function_nameContext) DATE_BIN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserDATE_BIN, 0)
}

func (s *Builtin_function_nameContext) DATE_PART() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserDATE_PART, 0)
}

func (s *Builtin_function_nameContext) DATE_TRUNC() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserDATE_TRUNC, 0)
}

func (s *Builtin_function_nameContext) ISFINITE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserISFINITE, 0)
}

func (s *Builtin_function_nameContext) JUSTIFY_DAYS() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserJUSTIFY_DAYS, 0)
}

func (s *Builtin_function_nameContext) JUSTIFY_HOURS() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserJUSTIFY_HOURS, 0)
}

func (s *Builtin_function_nameContext) JUSTIFY_INTERVAL() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserJUSTIFY_INTERVAL, 0)
}

func (s *Builtin_function_nameContext) MAKE_DATE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserMAKE_DATE, 0)
}

func (s *Builtin_function_nameContext) MAKE_INTERVAL() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserMAKE_INTERVAL, 0)
}

func (s *Builtin_function_nameContext) MAKE_TIME() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserMAKE_TIME, 0)
}

func (s *Builtin_function_nameContext) MAKE_TIMESTAMP() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserMAKE_TIMESTAMP, 0)
}

func (s *Builtin_function_nameContext) MAKE_TIMESTAMPTZ() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserMAKE_TIMESTAMPTZ, 0)
}

func (s *Builtin_function_nameContext) CLOCK_TIMESTAMP() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCLOCK_TIMESTAMP, 0)
}

func (s *Builtin_function_nameContext) NOW() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserNOW, 0)
}

func (s *Builtin_function_nameContext) STATEMENT_TIMESTAMP() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserSTATEMENT_TIMESTAMP, 0)
}

func (s *Builtin_function_nameContext) TIMEOFDAY() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserTIMEOFDAY, 0)
}

func (s *Builtin_function_nameContext) TRANSACTION_TIMESTAMP() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserTRANSACTION_TIMESTAMP, 0)
}

func (s *Builtin_function_nameContext) TO_TIMESTAMP() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserTO_TIMESTAMP, 0)
}

func (s *Builtin_function_nameContext) TO_CHAR() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserTO_CHAR, 0)
}

func (s *Builtin_function_nameContext) TO_DATE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserTO_DATE, 0)
}

func (s *Builtin_function_nameContext) TO_NUMBER() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserTO_NUMBER, 0)
}

func (s *Builtin_function_nameContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Builtin_function_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Builtin_function_nameContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterBuiltin_function_name(s)
	}
}

func (s *Builtin_function_nameContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitBuiltin_function_name(s)
	}
}

func (s *Builtin_function_nameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitBuiltin_function_name(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Builtin_function_name() (localctx IBuiltin_function_nameContext) {
	localctx = NewBuiltin_function_nameContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1394, PostgreSQLParserRULE_builtin_function_name)
	var _la int

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(9950)
		_la = p.GetTokenStream().LA(1)

		if !(_la == PostgreSQLParserREPLACE || ((int64((_la-418)) & ^0x3f) == 0 && ((int64(1)<<(_la-418))&127) != 0) || ((int64((_la-504)) & ^0x3f) == 0 && ((int64(1)<<(_la-504))&-130559) != 0) || ((int64((_la-568)) & ^0x3f) == 0 && ((int64(1)<<(_la-568))&-1) != 0) || ((int64((_la-632)) & ^0x3f) == 0 && ((int64(1)<<(_la-632))&15) != 0)) {
			p.GetErrorHandler().RecoverInline(p)
		} else {
			p.GetErrorHandler().ReportMatch(p)
			p.Consume()
		}
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IPl_functionContext is an interface to support dynamic dispatch.
type IPl_functionContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Comp_options() IComp_optionsContext
	Pl_block() IPl_blockContext
	Opt_semi() IOpt_semiContext

	// IsPl_functionContext differentiates from other interfaces.
	IsPl_functionContext()
}

type Pl_functionContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyPl_functionContext() *Pl_functionContext {
	var p = new(Pl_functionContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_pl_function
	return p
}

func InitEmptyPl_functionContext(p *Pl_functionContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_pl_function
}

func (*Pl_functionContext) IsPl_functionContext() {}

func NewPl_functionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Pl_functionContext {
	var p = new(Pl_functionContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_pl_function

	return p
}

func (s *Pl_functionContext) GetParser() antlr.Parser { return s.parser }

func (s *Pl_functionContext) Comp_options() IComp_optionsContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IComp_optionsContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IComp_optionsContext)
}

func (s *Pl_functionContext) Pl_block() IPl_blockContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IPl_blockContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IPl_blockContext)
}

func (s *Pl_functionContext) Opt_semi() IOpt_semiContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOpt_semiContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOpt_semiContext)
}

func (s *Pl_functionContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Pl_functionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Pl_functionContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterPl_function(s)
	}
}

func (s *Pl_functionContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitPl_function(s)
	}
}

func (s *Pl_functionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitPl_function(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Pl_function() (localctx IPl_functionContext) {
	localctx = NewPl_functionContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1396, PostgreSQLParserRULE_pl_function)
	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(9952)
		p.Comp_options()
	}
	{
		p.SetState(9953)
		p.Pl_block()
	}
	{
		p.SetState(9954)
		p.Opt_semi()
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IComp_optionsContext is an interface to support dynamic dispatch.
type IComp_optionsContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	AllComp_option() []IComp_optionContext
	Comp_option(i int) IComp_optionContext

	// IsComp_optionsContext differentiates from other interfaces.
	IsComp_optionsContext()
}

type Comp_optionsContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyComp_optionsContext() *Comp_optionsContext {
	var p = new(Comp_optionsContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_comp_options
	return p
}

func InitEmptyComp_optionsContext(p *Comp_optionsContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_comp_options
}

func (*Comp_optionsContext) IsComp_optionsContext() {}

func NewComp_optionsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Comp_optionsContext {
	var p = new(Comp_optionsContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_comp_options

	return p
}

func (s *Comp_optionsContext) GetParser() antlr.Parser { return s.parser }

func (s *Comp_optionsContext) AllComp_option() []IComp_optionContext {
	children := s.GetChildren()
	len := 0
	for _, ctx := range children {
		if _, ok := ctx.(IComp_optionContext); ok {
			len++
		}
	}

	tst := make([]IComp_optionContext, len)
	i := 0
	for _, ctx := range children {
		if t, ok := ctx.(IComp_optionContext); ok {
			tst[i] = t.(IComp_optionContext)
			i++
		}
	}

	return tst
}

func (s *Comp_optionsContext) Comp_option(i int) IComp_optionContext {
	var t antlr.RuleContext
	j := 0
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IComp_optionContext); ok {
			if j == i {
				t = ctx.(antlr.RuleContext)
				break
			}
			j++
		}
	}

	if t == nil {
		return nil
	}

	return t.(IComp_optionContext)
}

func (s *Comp_optionsContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Comp_optionsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Comp_optionsContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterComp_options(s)
	}
}

func (s *Comp_optionsContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitComp_options(s)
	}
}

func (s *Comp_optionsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitComp_options(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Comp_options() (localctx IComp_optionsContext) {
	localctx = NewComp_optionsContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1398, PostgreSQLParserRULE_comp_options)
	var _la int

	p.EnterOuterAlt(localctx, 1)
	p.SetState(9959)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}
	_la = p.GetTokenStream().LA(1)

	for _la == PostgreSQLParserOperator {
		{
			p.SetState(9956)
			p.Comp_option()
		}

		p.SetState(9961)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}
		_la = p.GetTokenStream().LA(1)
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IComp_optionContext is an interface to support dynamic dispatch.
type IComp_optionContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Sharp() ISharpContext
	OPTION() antlr.TerminalNode
	DUMP() antlr.TerminalNode
	PRINT_STRICT_PARAMS() antlr.TerminalNode
	Option_value() IOption_valueContext
	VARIABLE_CONFLICT() antlr.TerminalNode
	ERROR() antlr.TerminalNode
	USE_VARIABLE() antlr.TerminalNode
	USE_COLUMN() antlr.TerminalNode

	// IsComp_optionContext differentiates from other interfaces.
	IsComp_optionContext()
}

type Comp_optionContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyComp_optionContext() *Comp_optionContext {
	var p = new(Comp_optionContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_comp_option
	return p
}

func InitEmptyComp_optionContext(p *Comp_optionContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_comp_option
}

func (*Comp_optionContext) IsComp_optionContext() {}

func NewComp_optionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Comp_optionContext {
	var p = new(Comp_optionContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_comp_option

	return p
}

func (s *Comp_optionContext) GetParser() antlr.Parser { return s.parser }

func (s *Comp_optionContext) Sharp() ISharpContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ISharpContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ISharpContext)
}

func (s *Comp_optionContext) OPTION() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserOPTION, 0)
}

func (s *Comp_optionContext) DUMP() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserDUMP, 0)
}

func (s *Comp_optionContext) PRINT_STRICT_PARAMS() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserPRINT_STRICT_PARAMS, 0)
}

func (s *Comp_optionContext) Option_value() IOption_valueContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOption_valueContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOption_valueContext)
}

func (s *Comp_optionContext) VARIABLE_CONFLICT() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserVARIABLE_CONFLICT, 0)
}

func (s *Comp_optionContext) ERROR() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserERROR, 0)
}

func (s *Comp_optionContext) USE_VARIABLE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserUSE_VARIABLE, 0)
}

func (s *Comp_optionContext) USE_COLUMN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserUSE_COLUMN, 0)
}

func (s *Comp_optionContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Comp_optionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Comp_optionContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterComp_option(s)
	}
}

func (s *Comp_optionContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitComp_option(s)
	}
}

func (s *Comp_optionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitComp_option(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Comp_option() (localctx IComp_optionContext) {
	localctx = NewComp_optionContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1400, PostgreSQLParserRULE_comp_option)
	p.SetState(9982)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 666, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(9962)
			p.Sharp()
		}
		{
			p.SetState(9963)
			p.Match(PostgreSQLParserOPTION)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(9964)
			p.Match(PostgreSQLParserDUMP)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(9966)
			p.Sharp()
		}
		{
			p.SetState(9967)
			p.Match(PostgreSQLParserPRINT_STRICT_PARAMS)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(9968)
			p.Option_value()
		}

	case 3:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(9970)
			p.Sharp()
		}
		{
			p.SetState(9971)
			p.Match(PostgreSQLParserVARIABLE_CONFLICT)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(9972)
			p.Match(PostgreSQLParserERROR)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 4:
		p.EnterOuterAlt(localctx, 4)
		{
			p.SetState(9974)
			p.Sharp()
		}
		{
			p.SetState(9975)
			p.Match(PostgreSQLParserVARIABLE_CONFLICT)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(9976)
			p.Match(PostgreSQLParserUSE_VARIABLE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 5:
		p.EnterOuterAlt(localctx, 5)
		{
			p.SetState(9978)
			p.Sharp()
		}
		{
			p.SetState(9979)
			p.Match(PostgreSQLParserVARIABLE_CONFLICT)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(9980)
			p.Match(PostgreSQLParserUSE_COLUMN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case antlr.ATNInvalidAltNumber:
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// ISharpContext is an interface to support dynamic dispatch.
type ISharpContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Operator() antlr.TerminalNode

	// IsSharpContext differentiates from other interfaces.
	IsSharpContext()
}

type SharpContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptySharpContext() *SharpContext {
	var p = new(SharpContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_sharp
	return p
}

func InitEmptySharpContext(p *SharpContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_sharp
}

func (*SharpContext) IsSharpContext() {}

func NewSharpContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SharpContext {
	var p = new(SharpContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_sharp

	return p
}

func (s *SharpContext) GetParser() antlr.Parser { return s.parser }

func (s *SharpContext) Operator() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserOperator, 0)
}

func (s *SharpContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *SharpContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *SharpContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterSharp(s)
	}
}

func (s *SharpContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitSharp(s)
	}
}

func (s *SharpContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitSharp(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Sharp() (localctx ISharpContext) {
	localctx = NewSharpContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1402, PostgreSQLParserRULE_sharp)
	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(9984)
		p.Match(PostgreSQLParserOperator)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IOption_valueContext is an interface to support dynamic dispatch.
type IOption_valueContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Sconst() ISconstContext
	Reserved_keyword() IReserved_keywordContext
	Plsql_unreserved_keyword() IPlsql_unreserved_keywordContext
	Unreserved_keyword() IUnreserved_keywordContext

	// IsOption_valueContext differentiates from other interfaces.
	IsOption_valueContext()
}

type Option_valueContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyOption_valueContext() *Option_valueContext {
	var p = new(Option_valueContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_option_value
	return p
}

func InitEmptyOption_valueContext(p *Option_valueContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_option_value
}

func (*Option_valueContext) IsOption_valueContext() {}

func NewOption_valueContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Option_valueContext {
	var p = new(Option_valueContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_option_value

	return p
}

func (s *Option_valueContext) GetParser() antlr.Parser { return s.parser }

func (s *Option_valueContext) Sconst() ISconstContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ISconstContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ISconstContext)
}

func (s *Option_valueContext) Reserved_keyword() IReserved_keywordContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IReserved_keywordContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IReserved_keywordContext)
}

func (s *Option_valueContext) Plsql_unreserved_keyword() IPlsql_unreserved_keywordContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IPlsql_unreserved_keywordContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IPlsql_unreserved_keywordContext)
}

func (s *Option_valueContext) Unreserved_keyword() IUnreserved_keywordContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IUnreserved_keywordContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IUnreserved_keywordContext)
}

func (s *Option_valueContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Option_valueContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Option_valueContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterOption_value(s)
	}
}

func (s *Option_valueContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitOption_value(s)
	}
}

func (s *Option_valueContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitOption_value(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Option_value() (localctx IOption_valueContext) {
	localctx = NewOption_valueContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1404, PostgreSQLParserRULE_option_value)
	p.SetState(9990)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 667, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(9986)
			p.Sconst()
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(9987)
			p.Reserved_keyword()
		}

	case 3:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(9988)
			p.Plsql_unreserved_keyword()
		}

	case 4:
		p.EnterOuterAlt(localctx, 4)
		{
			p.SetState(9989)
			p.Unreserved_keyword()
		}

	case antlr.ATNInvalidAltNumber:
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IOpt_semiContext is an interface to support dynamic dispatch.
type IOpt_semiContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	SEMI() antlr.TerminalNode

	// IsOpt_semiContext differentiates from other interfaces.
	IsOpt_semiContext()
}

type Opt_semiContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyOpt_semiContext() *Opt_semiContext {
	var p = new(Opt_semiContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opt_semi
	return p
}

func InitEmptyOpt_semiContext(p *Opt_semiContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opt_semi
}

func (*Opt_semiContext) IsOpt_semiContext() {}

func NewOpt_semiContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_semiContext {
	var p = new(Opt_semiContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_opt_semi

	return p
}

func (s *Opt_semiContext) GetParser() antlr.Parser { return s.parser }

func (s *Opt_semiContext) SEMI() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserSEMI, 0)
}

func (s *Opt_semiContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Opt_semiContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Opt_semiContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterOpt_semi(s)
	}
}

func (s *Opt_semiContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitOpt_semi(s)
	}
}

func (s *Opt_semiContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitOpt_semi(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Opt_semi() (localctx IOpt_semiContext) {
	localctx = NewOpt_semiContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1406, PostgreSQLParserRULE_opt_semi)
	p.SetState(9994)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetTokenStream().LA(1) {
	case PostgreSQLParserEOF:
		p.EnterOuterAlt(localctx, 1)

	case PostgreSQLParserSEMI:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(9993)
			p.Match(PostgreSQLParserSEMI)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	default:
		p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IPl_blockContext is an interface to support dynamic dispatch.
type IPl_blockContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Decl_sect() IDecl_sectContext
	BEGIN_P() antlr.TerminalNode
	Proc_sect() IProc_sectContext
	Exception_sect() IException_sectContext
	END_P() antlr.TerminalNode
	Opt_label() IOpt_labelContext

	// IsPl_blockContext differentiates from other interfaces.
	IsPl_blockContext()
}

type Pl_blockContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyPl_blockContext() *Pl_blockContext {
	var p = new(Pl_blockContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_pl_block
	return p
}

func InitEmptyPl_blockContext(p *Pl_blockContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_pl_block
}

func (*Pl_blockContext) IsPl_blockContext() {}

func NewPl_blockContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Pl_blockContext {
	var p = new(Pl_blockContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_pl_block

	return p
}

func (s *Pl_blockContext) GetParser() antlr.Parser { return s.parser }

func (s *Pl_blockContext) Decl_sect() IDecl_sectContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IDecl_sectContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IDecl_sectContext)
}

func (s *Pl_blockContext) BEGIN_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserBEGIN_P, 0)
}

func (s *Pl_blockContext) Proc_sect() IProc_sectContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IProc_sectContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IProc_sectContext)
}

func (s *Pl_blockContext) Exception_sect() IException_sectContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IException_sectContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IException_sectContext)
}

func (s *Pl_blockContext) END_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserEND_P, 0)
}

func (s *Pl_blockContext) Opt_label() IOpt_labelContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOpt_labelContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOpt_labelContext)
}

func (s *Pl_blockContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Pl_blockContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Pl_blockContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterPl_block(s)
	}
}

func (s *Pl_blockContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitPl_block(s)
	}
}

func (s *Pl_blockContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitPl_block(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Pl_block() (localctx IPl_blockContext) {
	localctx = NewPl_blockContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1408, PostgreSQLParserRULE_pl_block)
	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(9996)
		p.Decl_sect()
	}
	{
		p.SetState(9997)
		p.Match(PostgreSQLParserBEGIN_P)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(9998)
		p.Proc_sect()
	}
	{
		p.SetState(9999)
		p.Exception_sect()
	}
	{
		p.SetState(10000)
		p.Match(PostgreSQLParserEND_P)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(10001)
		p.Opt_label()
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IDecl_sectContext is an interface to support dynamic dispatch.
type IDecl_sectContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Opt_block_label() IOpt_block_labelContext
	Decl_start() IDecl_startContext
	Decl_stmts() IDecl_stmtsContext

	// IsDecl_sectContext differentiates from other interfaces.
	IsDecl_sectContext()
}

type Decl_sectContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyDecl_sectContext() *Decl_sectContext {
	var p = new(Decl_sectContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_decl_sect
	return p
}

func InitEmptyDecl_sectContext(p *Decl_sectContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_decl_sect
}

func (*Decl_sectContext) IsDecl_sectContext() {}

func NewDecl_sectContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Decl_sectContext {
	var p = new(Decl_sectContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_decl_sect

	return p
}

func (s *Decl_sectContext) GetParser() antlr.Parser { return s.parser }

func (s *Decl_sectContext) Opt_block_label() IOpt_block_labelContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOpt_block_labelContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOpt_block_labelContext)
}

func (s *Decl_sectContext) Decl_start() IDecl_startContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IDecl_startContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IDecl_startContext)
}

func (s *Decl_sectContext) Decl_stmts() IDecl_stmtsContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IDecl_stmtsContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IDecl_stmtsContext)
}

func (s *Decl_sectContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Decl_sectContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Decl_sectContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterDecl_sect(s)
	}
}

func (s *Decl_sectContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitDecl_sect(s)
	}
}

func (s *Decl_sectContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitDecl_sect(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Decl_sect() (localctx IDecl_sectContext) {
	localctx = NewDecl_sectContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1410, PostgreSQLParserRULE_decl_sect)
	var _la int

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(10003)
		p.Opt_block_label()
	}
	p.SetState(10008)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}
	_la = p.GetTokenStream().LA(1)

	if _la == PostgreSQLParserDECLARE {
		{
			p.SetState(10004)
			p.Decl_start()
		}
		p.SetState(10006)
		p.GetErrorHandler().Sync(p)

		if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 669, p.GetParserRuleContext()) == 1 {
			{
				p.SetState(10005)
				p.Decl_stmts()
			}

		} else if p.HasError() { // JIM
			goto errorExit
		}

	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IDecl_startContext is an interface to support dynamic dispatch.
type IDecl_startContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	DECLARE() antlr.TerminalNode

	// IsDecl_startContext differentiates from other interfaces.
	IsDecl_startContext()
}

type Decl_startContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyDecl_startContext() *Decl_startContext {
	var p = new(Decl_startContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_decl_start
	return p
}

func InitEmptyDecl_startContext(p *Decl_startContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_decl_start
}

func (*Decl_startContext) IsDecl_startContext() {}

func NewDecl_startContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Decl_startContext {
	var p = new(Decl_startContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_decl_start

	return p
}

func (s *Decl_startContext) GetParser() antlr.Parser { return s.parser }

func (s *Decl_startContext) DECLARE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserDECLARE, 0)
}

func (s *Decl_startContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Decl_startContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Decl_startContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterDecl_start(s)
	}
}

func (s *Decl_startContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitDecl_start(s)
	}
}

func (s *Decl_startContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitDecl_start(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Decl_start() (localctx IDecl_startContext) {
	localctx = NewDecl_startContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1412, PostgreSQLParserRULE_decl_start)
	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(10010)
		p.Match(PostgreSQLParserDECLARE)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IDecl_stmtsContext is an interface to support dynamic dispatch.
type IDecl_stmtsContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	AllDecl_stmt() []IDecl_stmtContext
	Decl_stmt(i int) IDecl_stmtContext

	// IsDecl_stmtsContext differentiates from other interfaces.
	IsDecl_stmtsContext()
}

type Decl_stmtsContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyDecl_stmtsContext() *Decl_stmtsContext {
	var p = new(Decl_stmtsContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_decl_stmts
	return p
}

func InitEmptyDecl_stmtsContext(p *Decl_stmtsContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_decl_stmts
}

func (*Decl_stmtsContext) IsDecl_stmtsContext() {}

func NewDecl_stmtsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Decl_stmtsContext {
	var p = new(Decl_stmtsContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_decl_stmts

	return p
}

func (s *Decl_stmtsContext) GetParser() antlr.Parser { return s.parser }

func (s *Decl_stmtsContext) AllDecl_stmt() []IDecl_stmtContext {
	children := s.GetChildren()
	len := 0
	for _, ctx := range children {
		if _, ok := ctx.(IDecl_stmtContext); ok {
			len++
		}
	}

	tst := make([]IDecl_stmtContext, len)
	i := 0
	for _, ctx := range children {
		if t, ok := ctx.(IDecl_stmtContext); ok {
			tst[i] = t.(IDecl_stmtContext)
			i++
		}
	}

	return tst
}

func (s *Decl_stmtsContext) Decl_stmt(i int) IDecl_stmtContext {
	var t antlr.RuleContext
	j := 0
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IDecl_stmtContext); ok {
			if j == i {
				t = ctx.(antlr.RuleContext)
				break
			}
			j++
		}
	}

	if t == nil {
		return nil
	}

	return t.(IDecl_stmtContext)
}

func (s *Decl_stmtsContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Decl_stmtsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Decl_stmtsContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterDecl_stmts(s)
	}
}

func (s *Decl_stmtsContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitDecl_stmts(s)
	}
}

func (s *Decl_stmtsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitDecl_stmts(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Decl_stmts() (localctx IDecl_stmtsContext) {
	localctx = NewDecl_stmtsContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1414, PostgreSQLParserRULE_decl_stmts)
	var _alt int

	p.EnterOuterAlt(localctx, 1)
	p.SetState(10013)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}
	_alt = 1
	for ok := true; ok; ok = _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
		switch _alt {
		case 1:
			{
				p.SetState(10012)
				p.Decl_stmt()
			}

		default:
			p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
			goto errorExit
		}

		p.SetState(10015)
		p.GetErrorHandler().Sync(p)
		_alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 671, p.GetParserRuleContext())
		if p.HasError() {
			goto errorExit
		}
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// ILabel_declContext is an interface to support dynamic dispatch.
type ILabel_declContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	LESS_LESS() antlr.TerminalNode
	Any_identifier() IAny_identifierContext
	GREATER_GREATER() antlr.TerminalNode

	// IsLabel_declContext differentiates from other interfaces.
	IsLabel_declContext()
}

type Label_declContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyLabel_declContext() *Label_declContext {
	var p = new(Label_declContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_label_decl
	return p
}

func InitEmptyLabel_declContext(p *Label_declContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_label_decl
}

func (*Label_declContext) IsLabel_declContext() {}

func NewLabel_declContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Label_declContext {
	var p = new(Label_declContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_label_decl

	return p
}

func (s *Label_declContext) GetParser() antlr.Parser { return s.parser }

func (s *Label_declContext) LESS_LESS() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserLESS_LESS, 0)
}

func (s *Label_declContext) Any_identifier() IAny_identifierContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IAny_identifierContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IAny_identifierContext)
}

func (s *Label_declContext) GREATER_GREATER() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserGREATER_GREATER, 0)
}

func (s *Label_declContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Label_declContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Label_declContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterLabel_decl(s)
	}
}

func (s *Label_declContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitLabel_decl(s)
	}
}

func (s *Label_declContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitLabel_decl(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Label_decl() (localctx ILabel_declContext) {
	localctx = NewLabel_declContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1416, PostgreSQLParserRULE_label_decl)
	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(10017)
		p.Match(PostgreSQLParserLESS_LESS)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(10018)
		p.Any_identifier()
	}
	{
		p.SetState(10019)
		p.Match(PostgreSQLParserGREATER_GREATER)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IDecl_stmtContext is an interface to support dynamic dispatch.
type IDecl_stmtContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Decl_statement() IDecl_statementContext
	DECLARE() antlr.TerminalNode
	Label_decl() ILabel_declContext

	// IsDecl_stmtContext differentiates from other interfaces.
	IsDecl_stmtContext()
}

type Decl_stmtContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyDecl_stmtContext() *Decl_stmtContext {
	var p = new(Decl_stmtContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_decl_stmt
	return p
}

func InitEmptyDecl_stmtContext(p *Decl_stmtContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_decl_stmt
}

func (*Decl_stmtContext) IsDecl_stmtContext() {}

func NewDecl_stmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Decl_stmtContext {
	var p = new(Decl_stmtContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_decl_stmt

	return p
}

func (s *Decl_stmtContext) GetParser() antlr.Parser { return s.parser }

func (s *Decl_stmtContext) Decl_statement() IDecl_statementContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IDecl_statementContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IDecl_statementContext)
}

func (s *Decl_stmtContext) DECLARE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserDECLARE, 0)
}

func (s *Decl_stmtContext) Label_decl() ILabel_declContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ILabel_declContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ILabel_declContext)
}

func (s *Decl_stmtContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Decl_stmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Decl_stmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterDecl_stmt(s)
	}
}

func (s *Decl_stmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitDecl_stmt(s)
	}
}

func (s *Decl_stmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitDecl_stmt(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Decl_stmt() (localctx IDecl_stmtContext) {
	localctx = NewDecl_stmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1418, PostgreSQLParserRULE_decl_stmt)
	p.SetState(10024)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 672, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(10021)
			p.Decl_statement()
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(10022)
			p.Match(PostgreSQLParserDECLARE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 3:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(10023)
			p.Label_decl()
		}

	case antlr.ATNInvalidAltNumber:
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IDecl_statementContext is an interface to support dynamic dispatch.
type IDecl_statementContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Decl_varname() IDecl_varnameContext
	SEMI() antlr.TerminalNode
	ALIAS() antlr.TerminalNode
	FOR() antlr.TerminalNode
	Decl_aliasitem() IDecl_aliasitemContext
	Decl_const() IDecl_constContext
	Decl_datatype() IDecl_datatypeContext
	Decl_collate() IDecl_collateContext
	Decl_notnull() IDecl_notnullContext
	Decl_defval() IDecl_defvalContext
	Opt_scrollable() IOpt_scrollableContext
	CURSOR() antlr.TerminalNode
	Decl_cursor_args() IDecl_cursor_argsContext
	Decl_is_for() IDecl_is_forContext
	Decl_cursor_query() IDecl_cursor_queryContext

	// IsDecl_statementContext differentiates from other interfaces.
	IsDecl_statementContext()
}

type Decl_statementContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyDecl_statementContext() *Decl_statementContext {
	var p = new(Decl_statementContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_decl_statement
	return p
}

func InitEmptyDecl_statementContext(p *Decl_statementContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_decl_statement
}

func (*Decl_statementContext) IsDecl_statementContext() {}

func NewDecl_statementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Decl_statementContext {
	var p = new(Decl_statementContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_decl_statement

	return p
}

func (s *Decl_statementContext) GetParser() antlr.Parser { return s.parser }

func (s *Decl_statementContext) Decl_varname() IDecl_varnameContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IDecl_varnameContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IDecl_varnameContext)
}

func (s *Decl_statementContext) SEMI() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserSEMI, 0)
}

func (s *Decl_statementContext) ALIAS() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserALIAS, 0)
}

func (s *Decl_statementContext) FOR() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserFOR, 0)
}

func (s *Decl_statementContext) Decl_aliasitem() IDecl_aliasitemContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IDecl_aliasitemContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IDecl_aliasitemContext)
}

func (s *Decl_statementContext) Decl_const() IDecl_constContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IDecl_constContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IDecl_constContext)
}

func (s *Decl_statementContext) Decl_datatype() IDecl_datatypeContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IDecl_datatypeContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IDecl_datatypeContext)
}

func (s *Decl_statementContext) Decl_collate() IDecl_collateContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IDecl_collateContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IDecl_collateContext)
}

func (s *Decl_statementContext) Decl_notnull() IDecl_notnullContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IDecl_notnullContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IDecl_notnullContext)
}

func (s *Decl_statementContext) Decl_defval() IDecl_defvalContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IDecl_defvalContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IDecl_defvalContext)
}

func (s *Decl_statementContext) Opt_scrollable() IOpt_scrollableContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOpt_scrollableContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOpt_scrollableContext)
}

func (s *Decl_statementContext) CURSOR() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCURSOR, 0)
}

func (s *Decl_statementContext) Decl_cursor_args() IDecl_cursor_argsContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IDecl_cursor_argsContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IDecl_cursor_argsContext)
}

func (s *Decl_statementContext) Decl_is_for() IDecl_is_forContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IDecl_is_forContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IDecl_is_forContext)
}

func (s *Decl_statementContext) Decl_cursor_query() IDecl_cursor_queryContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IDecl_cursor_queryContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IDecl_cursor_queryContext)
}

func (s *Decl_statementContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Decl_statementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Decl_statementContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterDecl_statement(s)
	}
}

func (s *Decl_statementContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitDecl_statement(s)
	}
}

func (s *Decl_statementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitDecl_statement(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Decl_statement() (localctx IDecl_statementContext) {
	localctx = NewDecl_statementContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1420, PostgreSQLParserRULE_decl_statement)
	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(10026)
		p.Decl_varname()
	}
	p.SetState(10042)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 673, p.GetParserRuleContext()) {
	case 1:
		{
			p.SetState(10027)
			p.Match(PostgreSQLParserALIAS)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(10028)
			p.Match(PostgreSQLParserFOR)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(10029)
			p.Decl_aliasitem()
		}

	case 2:
		{
			p.SetState(10030)
			p.Decl_const()
		}
		{
			p.SetState(10031)
			p.Decl_datatype()
		}
		{
			p.SetState(10032)
			p.Decl_collate()
		}
		{
			p.SetState(10033)
			p.Decl_notnull()
		}
		{
			p.SetState(10034)
			p.Decl_defval()
		}

	case 3:
		{
			p.SetState(10036)
			p.Opt_scrollable()
		}
		{
			p.SetState(10037)
			p.Match(PostgreSQLParserCURSOR)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(10038)
			p.Decl_cursor_args()
		}
		{
			p.SetState(10039)
			p.Decl_is_for()
		}
		{
			p.SetState(10040)
			p.Decl_cursor_query()
		}

	case antlr.ATNInvalidAltNumber:
		goto errorExit
	}
	{
		p.SetState(10044)
		p.Match(PostgreSQLParserSEMI)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IOpt_scrollableContext is an interface to support dynamic dispatch.
type IOpt_scrollableContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	NO() antlr.TerminalNode
	SCROLL() antlr.TerminalNode

	// IsOpt_scrollableContext differentiates from other interfaces.
	IsOpt_scrollableContext()
}

type Opt_scrollableContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyOpt_scrollableContext() *Opt_scrollableContext {
	var p = new(Opt_scrollableContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opt_scrollable
	return p
}

func InitEmptyOpt_scrollableContext(p *Opt_scrollableContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opt_scrollable
}

func (*Opt_scrollableContext) IsOpt_scrollableContext() {}

func NewOpt_scrollableContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_scrollableContext {
	var p = new(Opt_scrollableContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_opt_scrollable

	return p
}

func (s *Opt_scrollableContext) GetParser() antlr.Parser { return s.parser }

func (s *Opt_scrollableContext) NO() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserNO, 0)
}

func (s *Opt_scrollableContext) SCROLL() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserSCROLL, 0)
}

func (s *Opt_scrollableContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Opt_scrollableContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Opt_scrollableContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterOpt_scrollable(s)
	}
}

func (s *Opt_scrollableContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitOpt_scrollable(s)
	}
}

func (s *Opt_scrollableContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitOpt_scrollable(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Opt_scrollable() (localctx IOpt_scrollableContext) {
	localctx = NewOpt_scrollableContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1422, PostgreSQLParserRULE_opt_scrollable)
	p.SetState(10050)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetTokenStream().LA(1) {
	case PostgreSQLParserCURSOR:
		p.EnterOuterAlt(localctx, 1)

	case PostgreSQLParserNO:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(10047)
			p.Match(PostgreSQLParserNO)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(10048)
			p.Match(PostgreSQLParserSCROLL)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case PostgreSQLParserSCROLL:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(10049)
			p.Match(PostgreSQLParserSCROLL)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	default:
		p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IDecl_cursor_queryContext is an interface to support dynamic dispatch.
type IDecl_cursor_queryContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Selectstmt() ISelectstmtContext

	// IsDecl_cursor_queryContext differentiates from other interfaces.
	IsDecl_cursor_queryContext()
}

type Decl_cursor_queryContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyDecl_cursor_queryContext() *Decl_cursor_queryContext {
	var p = new(Decl_cursor_queryContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_decl_cursor_query
	return p
}

func InitEmptyDecl_cursor_queryContext(p *Decl_cursor_queryContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_decl_cursor_query
}

func (*Decl_cursor_queryContext) IsDecl_cursor_queryContext() {}

func NewDecl_cursor_queryContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Decl_cursor_queryContext {
	var p = new(Decl_cursor_queryContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_decl_cursor_query

	return p
}

func (s *Decl_cursor_queryContext) GetParser() antlr.Parser { return s.parser }

func (s *Decl_cursor_queryContext) Selectstmt() ISelectstmtContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ISelectstmtContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ISelectstmtContext)
}

func (s *Decl_cursor_queryContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Decl_cursor_queryContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Decl_cursor_queryContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterDecl_cursor_query(s)
	}
}

func (s *Decl_cursor_queryContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitDecl_cursor_query(s)
	}
}

func (s *Decl_cursor_queryContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitDecl_cursor_query(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Decl_cursor_query() (localctx IDecl_cursor_queryContext) {
	localctx = NewDecl_cursor_queryContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1424, PostgreSQLParserRULE_decl_cursor_query)
	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(10052)
		p.Selectstmt()
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IDecl_cursor_argsContext is an interface to support dynamic dispatch.
type IDecl_cursor_argsContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	OPEN_PAREN() antlr.TerminalNode
	Decl_cursor_arglist() IDecl_cursor_arglistContext
	CLOSE_PAREN() antlr.TerminalNode

	// IsDecl_cursor_argsContext differentiates from other interfaces.
	IsDecl_cursor_argsContext()
}

type Decl_cursor_argsContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyDecl_cursor_argsContext() *Decl_cursor_argsContext {
	var p = new(Decl_cursor_argsContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_decl_cursor_args
	return p
}

func InitEmptyDecl_cursor_argsContext(p *Decl_cursor_argsContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_decl_cursor_args
}

func (*Decl_cursor_argsContext) IsDecl_cursor_argsContext() {}

func NewDecl_cursor_argsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Decl_cursor_argsContext {
	var p = new(Decl_cursor_argsContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_decl_cursor_args

	return p
}

func (s *Decl_cursor_argsContext) GetParser() antlr.Parser { return s.parser }

func (s *Decl_cursor_argsContext) OPEN_PAREN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserOPEN_PAREN, 0)
}

func (s *Decl_cursor_argsContext) Decl_cursor_arglist() IDecl_cursor_arglistContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IDecl_cursor_arglistContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IDecl_cursor_arglistContext)
}

func (s *Decl_cursor_argsContext) CLOSE_PAREN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCLOSE_PAREN, 0)
}

func (s *Decl_cursor_argsContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Decl_cursor_argsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Decl_cursor_argsContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterDecl_cursor_args(s)
	}
}

func (s *Decl_cursor_argsContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitDecl_cursor_args(s)
	}
}

func (s *Decl_cursor_argsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitDecl_cursor_args(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Decl_cursor_args() (localctx IDecl_cursor_argsContext) {
	localctx = NewDecl_cursor_argsContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1426, PostgreSQLParserRULE_decl_cursor_args)
	p.SetState(10059)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetTokenStream().LA(1) {
	case PostgreSQLParserFOR, PostgreSQLParserIS:
		p.EnterOuterAlt(localctx, 1)

	case PostgreSQLParserOPEN_PAREN:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(10055)
			p.Match(PostgreSQLParserOPEN_PAREN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(10056)
			p.Decl_cursor_arglist()
		}
		{
			p.SetState(10057)
			p.Match(PostgreSQLParserCLOSE_PAREN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	default:
		p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IDecl_cursor_arglistContext is an interface to support dynamic dispatch.
type IDecl_cursor_arglistContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	AllDecl_cursor_arg() []IDecl_cursor_argContext
	Decl_cursor_arg(i int) IDecl_cursor_argContext
	AllCOMMA() []antlr.TerminalNode
	COMMA(i int) antlr.TerminalNode

	// IsDecl_cursor_arglistContext differentiates from other interfaces.
	IsDecl_cursor_arglistContext()
}

type Decl_cursor_arglistContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyDecl_cursor_arglistContext() *Decl_cursor_arglistContext {
	var p = new(Decl_cursor_arglistContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_decl_cursor_arglist
	return p
}

func InitEmptyDecl_cursor_arglistContext(p *Decl_cursor_arglistContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_decl_cursor_arglist
}

func (*Decl_cursor_arglistContext) IsDecl_cursor_arglistContext() {}

func NewDecl_cursor_arglistContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Decl_cursor_arglistContext {
	var p = new(Decl_cursor_arglistContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_decl_cursor_arglist

	return p
}

func (s *Decl_cursor_arglistContext) GetParser() antlr.Parser { return s.parser }

func (s *Decl_cursor_arglistContext) AllDecl_cursor_arg() []IDecl_cursor_argContext {
	children := s.GetChildren()
	len := 0
	for _, ctx := range children {
		if _, ok := ctx.(IDecl_cursor_argContext); ok {
			len++
		}
	}

	tst := make([]IDecl_cursor_argContext, len)
	i := 0
	for _, ctx := range children {
		if t, ok := ctx.(IDecl_cursor_argContext); ok {
			tst[i] = t.(IDecl_cursor_argContext)
			i++
		}
	}

	return tst
}

func (s *Decl_cursor_arglistContext) Decl_cursor_arg(i int) IDecl_cursor_argContext {
	var t antlr.RuleContext
	j := 0
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IDecl_cursor_argContext); ok {
			if j == i {
				t = ctx.(antlr.RuleContext)
				break
			}
			j++
		}
	}

	if t == nil {
		return nil
	}

	return t.(IDecl_cursor_argContext)
}

func (s *Decl_cursor_arglistContext) AllCOMMA() []antlr.TerminalNode {
	return s.GetTokens(PostgreSQLParserCOMMA)
}

func (s *Decl_cursor_arglistContext) COMMA(i int) antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCOMMA, i)
}

func (s *Decl_cursor_arglistContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Decl_cursor_arglistContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Decl_cursor_arglistContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterDecl_cursor_arglist(s)
	}
}

func (s *Decl_cursor_arglistContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitDecl_cursor_arglist(s)
	}
}

func (s *Decl_cursor_arglistContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitDecl_cursor_arglist(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Decl_cursor_arglist() (localctx IDecl_cursor_arglistContext) {
	localctx = NewDecl_cursor_arglistContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1428, PostgreSQLParserRULE_decl_cursor_arglist)
	var _la int

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(10061)
		p.Decl_cursor_arg()
	}
	p.SetState(10066)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}
	_la = p.GetTokenStream().LA(1)

	for _la == PostgreSQLParserCOMMA {
		{
			p.SetState(10062)
			p.Match(PostgreSQLParserCOMMA)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(10063)
			p.Decl_cursor_arg()
		}

		p.SetState(10068)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}
		_la = p.GetTokenStream().LA(1)
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IDecl_cursor_argContext is an interface to support dynamic dispatch.
type IDecl_cursor_argContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Decl_varname() IDecl_varnameContext
	Decl_datatype() IDecl_datatypeContext

	// IsDecl_cursor_argContext differentiates from other interfaces.
	IsDecl_cursor_argContext()
}

type Decl_cursor_argContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyDecl_cursor_argContext() *Decl_cursor_argContext {
	var p = new(Decl_cursor_argContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_decl_cursor_arg
	return p
}

func InitEmptyDecl_cursor_argContext(p *Decl_cursor_argContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_decl_cursor_arg
}

func (*Decl_cursor_argContext) IsDecl_cursor_argContext() {}

func NewDecl_cursor_argContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Decl_cursor_argContext {
	var p = new(Decl_cursor_argContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_decl_cursor_arg

	return p
}

func (s *Decl_cursor_argContext) GetParser() antlr.Parser { return s.parser }

func (s *Decl_cursor_argContext) Decl_varname() IDecl_varnameContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IDecl_varnameContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IDecl_varnameContext)
}

func (s *Decl_cursor_argContext) Decl_datatype() IDecl_datatypeContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IDecl_datatypeContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IDecl_datatypeContext)
}

func (s *Decl_cursor_argContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Decl_cursor_argContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Decl_cursor_argContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterDecl_cursor_arg(s)
	}
}

func (s *Decl_cursor_argContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitDecl_cursor_arg(s)
	}
}

func (s *Decl_cursor_argContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitDecl_cursor_arg(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Decl_cursor_arg() (localctx IDecl_cursor_argContext) {
	localctx = NewDecl_cursor_argContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1430, PostgreSQLParserRULE_decl_cursor_arg)
	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(10069)
		p.Decl_varname()
	}
	{
		p.SetState(10070)
		p.Decl_datatype()
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IDecl_is_forContext is an interface to support dynamic dispatch.
type IDecl_is_forContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	IS() antlr.TerminalNode
	FOR() antlr.TerminalNode

	// IsDecl_is_forContext differentiates from other interfaces.
	IsDecl_is_forContext()
}

type Decl_is_forContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyDecl_is_forContext() *Decl_is_forContext {
	var p = new(Decl_is_forContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_decl_is_for
	return p
}

func InitEmptyDecl_is_forContext(p *Decl_is_forContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_decl_is_for
}

func (*Decl_is_forContext) IsDecl_is_forContext() {}

func NewDecl_is_forContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Decl_is_forContext {
	var p = new(Decl_is_forContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_decl_is_for

	return p
}

func (s *Decl_is_forContext) GetParser() antlr.Parser { return s.parser }

func (s *Decl_is_forContext) IS() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserIS, 0)
}

func (s *Decl_is_forContext) FOR() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserFOR, 0)
}

func (s *Decl_is_forContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Decl_is_forContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Decl_is_forContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterDecl_is_for(s)
	}
}

func (s *Decl_is_forContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitDecl_is_for(s)
	}
}

func (s *Decl_is_forContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitDecl_is_for(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Decl_is_for() (localctx IDecl_is_forContext) {
	localctx = NewDecl_is_forContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1432, PostgreSQLParserRULE_decl_is_for)
	var _la int

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(10072)
		_la = p.GetTokenStream().LA(1)

		if !(_la == PostgreSQLParserFOR || _la == PostgreSQLParserIS) {
			p.GetErrorHandler().RecoverInline(p)
		} else {
			p.GetErrorHandler().ReportMatch(p)
			p.Consume()
		}
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IDecl_aliasitemContext is an interface to support dynamic dispatch.
type IDecl_aliasitemContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	PARAM() antlr.TerminalNode
	Colid() IColidContext

	// IsDecl_aliasitemContext differentiates from other interfaces.
	IsDecl_aliasitemContext()
}

type Decl_aliasitemContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyDecl_aliasitemContext() *Decl_aliasitemContext {
	var p = new(Decl_aliasitemContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_decl_aliasitem
	return p
}

func InitEmptyDecl_aliasitemContext(p *Decl_aliasitemContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_decl_aliasitem
}

func (*Decl_aliasitemContext) IsDecl_aliasitemContext() {}

func NewDecl_aliasitemContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Decl_aliasitemContext {
	var p = new(Decl_aliasitemContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_decl_aliasitem

	return p
}

func (s *Decl_aliasitemContext) GetParser() antlr.Parser { return s.parser }

func (s *Decl_aliasitemContext) PARAM() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserPARAM, 0)
}

func (s *Decl_aliasitemContext) Colid() IColidContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IColidContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IColidContext)
}

func (s *Decl_aliasitemContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Decl_aliasitemContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Decl_aliasitemContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterDecl_aliasitem(s)
	}
}

func (s *Decl_aliasitemContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitDecl_aliasitem(s)
	}
}

func (s *Decl_aliasitemContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitDecl_aliasitem(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Decl_aliasitem() (localctx IDecl_aliasitemContext) {
	localctx = NewDecl_aliasitemContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1434, PostgreSQLParserRULE_decl_aliasitem)
	p.SetState(10076)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetTokenStream().LA(1) {
	case PostgreSQLParserPARAM:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(10074)
			p.Match(PostgreSQLParserPARAM)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case PostgreSQLParserAND, PostgreSQLParserARRAY, PostgreSQLParserCOLLATE, PostgreSQLParserCOLUMN, PostgreSQLParserCONSTRAINT, PostgreSQLParserDEFAULT, PostgreSQLParserDO, PostgreSQLParserFETCH, PostgreSQLParserTABLE, PostgreSQLParserIS, PostgreSQLParserLEFT, PostgreSQLParserOUTER_P, PostgreSQLParserOVER, PostgreSQLParserRIGHT, PostgreSQLParserABORT_P, PostgreSQLParserABSOLUTE_P, PostgreSQLParserACCESS, PostgreSQLParserACTION, PostgreSQLParserADD_P, PostgreSQLParserADMIN, PostgreSQLParserAFTER, PostgreSQLParserAGGREGATE, PostgreSQLParserALSO, PostgreSQLParserALTER, PostgreSQLParserALWAYS, PostgreSQLParserASSERTION, PostgreSQLParserASSIGNMENT, PostgreSQLParserAT, PostgreSQLParserATTRIBUTE, PostgreSQLParserBACKWARD, PostgreSQLParserBEFORE, PostgreSQLParserBEGIN_P, PostgreSQLParserBY, PostgreSQLParserCACHE, PostgreSQLParserCALLED, PostgreSQLParserCASCADE, PostgreSQLParserCASCADED, PostgreSQLParserCATALOG, PostgreSQLParserCHAIN, PostgreSQLParserCHARACTERISTICS, PostgreSQLParserCHECKPOINT, PostgreSQLParserCLASS, PostgreSQLParserCLOSE, PostgreSQLParserCLUSTER, PostgreSQLParserCOMMENT, PostgreSQLParserCOMMENTS, PostgreSQLParserCOMMIT, PostgreSQLParserCOMMITTED, PostgreSQLParserCONFIGURATION, PostgreSQLParserCONNECTION, PostgreSQLParserCONSTRAINTS, PostgreSQLParserCONTENT_P, PostgreSQLParserCONTINUE_P, PostgreSQLParserCONVERSION_P, PostgreSQLParserCOPY, PostgreSQLParserCOST, PostgreSQLParserCSV, PostgreSQLParserCURSOR, PostgreSQLParserCYCLE, PostgreSQLParserDATA_P, PostgreSQLParserDATABASE, PostgreSQLParserDAY_P, PostgreSQLParserDEALLOCATE, PostgreSQLParserDECLARE, PostgreSQLParserDEFAULTS, PostgreSQLParserDEFERRED, PostgreSQLParserDEFINER, PostgreSQLParserDELETE_P, PostgreSQLParserDELIMITER, PostgreSQLParserDELIMITERS, PostgreSQLParserDICTIONARY, PostgreSQLParserDISABLE_P, PostgreSQLParserDISCARD, PostgreSQLParserDOCUMENT_P, PostgreSQLParserDOMAIN_P, PostgreSQLParserDOUBLE_P, PostgreSQLParserDROP, PostgreSQLParserEACH, PostgreSQLParserENABLE_P, PostgreSQLParserENCODING, PostgreSQLParserENCRYPTED, PostgreSQLParserENUM_P, PostgreSQLParserESCAPE, PostgreSQLParserEVENT, PostgreSQLParserEXCLUDE, PostgreSQLParserEXCLUDING, PostgreSQLParserEXCLUSIVE, PostgreSQLParserEXECUTE, PostgreSQLParserEXPLAIN, PostgreSQLParserEXTENSION, PostgreSQLParserEXTERNAL, PostgreSQLParserFAMILY, PostgreSQLParserFIRST_P, PostgreSQLParserFOLLOWING, PostgreSQLParserFORCE, PostgreSQLParserFORWARD, PostgreSQLParserFUNCTION, PostgreSQLParserFUNCTIONS, PostgreSQLParserGLOBAL, PostgreSQLParserGRANTED, PostgreSQLParserHANDLER, PostgreSQLParserHEADER_P, PostgreSQLParserHOLD, PostgreSQLParserHOUR_P, PostgreSQLParserIDENTITY_P, PostgreSQLParserIF_P, PostgreSQLParserIMMEDIATE, PostgreSQLParserIMMUTABLE, PostgreSQLParserIMPLICIT_P, PostgreSQLParserINCLUDING, PostgreSQLParserINCREMENT, PostgreSQLParserINDEX, PostgreSQLParserINDEXES, PostgreSQLParserINHERIT, PostgreSQLParserINHERITS, PostgreSQLParserINLINE_P, PostgreSQLParserINSENSITIVE, PostgreSQLParserINSERT, PostgreSQLParserINSTEAD, PostgreSQLParserINVOKER, PostgreSQLParserISOLATION, PostgreSQLParserKEY, PostgreSQLParserLABEL, PostgreSQLParserLANGUAGE, PostgreSQLParserLARGE_P, PostgreSQLParserLAST_P, PostgreSQLParserLEAKPROOF, PostgreSQLParserLEVEL, PostgreSQLParserLISTEN, PostgreSQLParserLOAD, PostgreSQLParserLOCAL, PostgreSQLParserLOCATION, PostgreSQLParserLOCK_P, PostgreSQLParserMAPPING, PostgreSQLParserMATCH, PostgreSQLParserMATERIALIZED, PostgreSQLParserMAXVALUE, PostgreSQLParserMINUTE_P, PostgreSQLParserMINVALUE, PostgreSQLParserMODE, PostgreSQLParserMONTH_P, PostgreSQLParserMOVE, PostgreSQLParserNAME_P, PostgreSQLParserNAMES, PostgreSQLParserNEXT, PostgreSQLParserNO, PostgreSQLParserNOTHING, PostgreSQLParserNOTIFY, PostgreSQLParserNOWAIT, PostgreSQLParserNULLS_P, PostgreSQLParserOBJECT_P, PostgreSQLParserOF, PostgreSQLParserOFF, PostgreSQLParserOIDS, PostgreSQLParserOPERATOR, PostgreSQLParserOPTION, PostgreSQLParserOPTIONS, PostgreSQLParserOWNED, PostgreSQLParserOWNER, PostgreSQLParserPARSER, PostgreSQLParserPARTIAL, PostgreSQLParserPARTITION, PostgreSQLParserPASSING, PostgreSQLParserPASSWORD, PostgreSQLParserPLANS, PostgreSQLParserPRECEDING, PostgreSQLParserPREPARE, PostgreSQLParserPREPARED, PostgreSQLParserPRESERVE, PostgreSQLParserPRIOR, PostgreSQLParserPRIVILEGES, PostgreSQLParserPROCEDURAL, PostgreSQLParserPROCEDURE, PostgreSQLParserPROGRAM, PostgreSQLParserQUOTE, PostgreSQLParserRANGE, PostgreSQLParserREAD, PostgreSQLParserREASSIGN, PostgreSQLParserRECHECK, PostgreSQLParserRECURSIVE, PostgreSQLParserREF, PostgreSQLParserREFRESH, PostgreSQLParserREINDEX, PostgreSQLParserRELATIVE_P, PostgreSQLParserRELEASE, PostgreSQLParserRENAME, PostgreSQLParserREPEATABLE, PostgreSQLParserREPLACE, PostgreSQLParserREPLICA, PostgreSQLParserRESET, PostgreSQLParserRESTART, PostgreSQLParserRESTRICT, PostgreSQLParserRETURNS, PostgreSQLParserREVOKE, PostgreSQLParserROLE, PostgreSQLParserROLLBACK, PostgreSQLParserROWS, PostgreSQLParserRULE, PostgreSQLParserSAVEPOINT, PostgreSQLParserSCHEMA, PostgreSQLParserSCROLL, PostgreSQLParserSEARCH, PostgreSQLParserSECOND_P, PostgreSQLParserSECURITY, PostgreSQLParserSEQUENCE, PostgreSQLParserSEQUENCES, PostgreSQLParserSERIALIZABLE, PostgreSQLParserSERVER, PostgreSQLParserSESSION, PostgreSQLParserSET, PostgreSQLParserSHARE, PostgreSQLParserSHOW, PostgreSQLParserSIMPLE, PostgreSQLParserSNAPSHOT, PostgreSQLParserSTABLE, PostgreSQLParserSTANDALONE_P, PostgreSQLParserSTART, PostgreSQLParserSTATEMENT, PostgreSQLParserSTATISTICS, PostgreSQLParserSTDIN, PostgreSQLParserSTDOUT, PostgreSQLParserSTORAGE, PostgreSQLParserSTRICT_P, PostgreSQLParserSTRIP_P, PostgreSQLParserSYSID, PostgreSQLParserSYSTEM_P, PostgreSQLParserTABLES, PostgreSQLParserTABLESPACE, PostgreSQLParserTEMP, PostgreSQLParserTEMPLATE, PostgreSQLParserTEMPORARY, PostgreSQLParserTEXT_P, PostgreSQLParserTRANSACTION, PostgreSQLParserTRIGGER, PostgreSQLParserTRUNCATE, PostgreSQLParserTRUSTED, PostgreSQLParserTYPE_P, PostgreSQLParserTYPES_P, PostgreSQLParserUNBOUNDED, PostgreSQLParserUNCOMMITTED, PostgreSQLParserUNENCRYPTED, PostgreSQLParserUNKNOWN, PostgreSQLParserUNLISTEN, PostgreSQLParserUNLOGGED, PostgreSQLParserUNTIL, PostgreSQLParserUPDATE, PostgreSQLParserVACUUM, PostgreSQLParserVALID, PostgreSQLParserVALIDATE, PostgreSQLParserVALIDATOR, PostgreSQLParserVARYING, PostgreSQLParserVERSION_P, PostgreSQLParserVIEW, PostgreSQLParserVOLATILE, PostgreSQLParserWHITESPACE_P, PostgreSQLParserWITHOUT, PostgreSQLParserWORK, PostgreSQLParserWRAPPER, PostgreSQLParserWRITE, PostgreSQLParserXML_P, PostgreSQLParserYEAR_P, PostgreSQLParserYES_P, PostgreSQLParserZONE, PostgreSQLParserBETWEEN, PostgreSQLParserBIGINT, PostgreSQLParserBIT, PostgreSQLParserBOOLEAN_P, PostgreSQLParserCHAR_P, PostgreSQLParserCHARACTER, PostgreSQLParserCOALESCE, PostgreSQLParserDEC, PostgreSQLParserDECIMAL_P, PostgreSQLParserEXISTS, PostgreSQLParserEXTRACT, PostgreSQLParserFLOAT_P, PostgreSQLParserGREATEST, PostgreSQLParserINOUT, PostgreSQLParserINT_P, PostgreSQLParserINTEGER, PostgreSQLParserINTERVAL, PostgreSQLParserLEAST, PostgreSQLParserNATIONAL, PostgreSQLParserNCHAR, PostgreSQLParserNONE, PostgreSQLParserNULLIF, PostgreSQLParserNUMERIC, PostgreSQLParserOVERLAY, PostgreSQLParserPOSITION, PostgreSQLParserPRECISION, PostgreSQLParserREAL, PostgreSQLParserROW, PostgreSQLParserSETOF, PostgreSQLParserSMALLINT, PostgreSQLParserSUBSTRING, PostgreSQLParserTIME, PostgreSQLParserTIMESTAMP, PostgreSQLParserTREAT, PostgreSQLParserTRIM, PostgreSQLParserVALUES, PostgreSQLParserVARCHAR, PostgreSQLParserXMLATTRIBUTES, PostgreSQLParserXMLCOMMENT, PostgreSQLParserXMLAGG, PostgreSQLParserXML_IS_WELL_FORMED, PostgreSQLParserXML_IS_WELL_FORMED_DOCUMENT, PostgreSQLParserXML_IS_WELL_FORMED_CONTENT, PostgreSQLParserXPATH, PostgreSQLParserXPATH_EXISTS, PostgreSQLParserXMLCONCAT, PostgreSQLParserXMLELEMENT, PostgreSQLParserXMLEXISTS, PostgreSQLParserXMLFOREST, PostgreSQLParserXMLPARSE, PostgreSQLParserXMLPI, PostgreSQLParserXMLROOT, PostgreSQLParserXMLSERIALIZE, PostgreSQLParserCALL, PostgreSQLParserCURRENT_P, PostgreSQLParserATTACH, PostgreSQLParserDETACH, PostgreSQLParserEXPRESSION, PostgreSQLParserGENERATED, PostgreSQLParserLOGGED, PostgreSQLParserSTORED, PostgreSQLParserINCLUDE, PostgreSQLParserROUTINE, PostgreSQLParserTRANSFORM, PostgreSQLParserIMPORT_P, PostgreSQLParserPOLICY, PostgreSQLParserMETHOD, PostgreSQLParserREFERENCING, PostgreSQLParserNEW, PostgreSQLParserOLD, PostgreSQLParserVALUE_P, PostgreSQLParserSUBSCRIPTION, PostgreSQLParserPUBLICATION, PostgreSQLParserOUT_P, PostgreSQLParserROUTINES, PostgreSQLParserSCHEMAS, PostgreSQLParserPROCEDURES, PostgreSQLParserINPUT_P, PostgreSQLParserSUPPORT, PostgreSQLParserPARALLEL, PostgreSQLParserSQL_P, PostgreSQLParserDEPENDS, PostgreSQLParserOVERRIDING, PostgreSQLParserCONFLICT, PostgreSQLParserSKIP_P, PostgreSQLParserLOCKED, PostgreSQLParserTIES, PostgreSQLParserROLLUP, PostgreSQLParserCUBE, PostgreSQLParserGROUPING, PostgreSQLParserSETS, PostgreSQLParserORDINALITY, PostgreSQLParserXMLTABLE, PostgreSQLParserCOLUMNS, PostgreSQLParserXMLNAMESPACES, PostgreSQLParserROWTYPE, PostgreSQLParserNORMALIZED, PostgreSQLParserWITHIN, PostgreSQLParserFILTER, PostgreSQLParserGROUPS, PostgreSQLParserOTHERS, PostgreSQLParserNFC, PostgreSQLParserNFD, PostgreSQLParserNFKC, PostgreSQLParserNFKD, PostgreSQLParserUESCAPE, PostgreSQLParserVIEWS, PostgreSQLParserNORMALIZE, PostgreSQLParserDUMP, PostgreSQLParserPRINT_STRICT_PARAMS, PostgreSQLParserVARIABLE_CONFLICT, PostgreSQLParserERROR, PostgreSQLParserUSE_VARIABLE, PostgreSQLParserUSE_COLUMN, PostgreSQLParserALIAS, PostgreSQLParserCONSTANT, PostgreSQLParserPERFORM, PostgreSQLParserGET, PostgreSQLParserDIAGNOSTICS, PostgreSQLParserSTACKED, PostgreSQLParserELSIF, PostgreSQLParserREVERSE, PostgreSQLParserSLICE, PostgreSQLParserEXIT, PostgreSQLParserRETURN, PostgreSQLParserQUERY, PostgreSQLParserRAISE, PostgreSQLParserSQLSTATE, PostgreSQLParserDEBUG, PostgreSQLParserLOG, PostgreSQLParserINFO, PostgreSQLParserNOTICE, PostgreSQLParserWARNING, PostgreSQLParserEXCEPTION, PostgreSQLParserASSERT, PostgreSQLParserOPEN, PostgreSQLParserABS, PostgreSQLParserCBRT, PostgreSQLParserCEIL, PostgreSQLParserCEILING, PostgreSQLParserDEGREES, PostgreSQLParserDIV, PostgreSQLParserEXP, PostgreSQLParserFACTORIAL, PostgreSQLParserFLOOR, PostgreSQLParserGCD, PostgreSQLParserLCM, PostgreSQLParserLN, PostgreSQLParserLOG10, PostgreSQLParserMIN_SCALE, PostgreSQLParserMOD, PostgreSQLParserPI, PostgreSQLParserPOWER, PostgreSQLParserRADIANS, PostgreSQLParserROUND, PostgreSQLParserSCALE, PostgreSQLParserSIGN, PostgreSQLParserSQRT, PostgreSQLParserTRIM_SCALE, PostgreSQLParserTRUNC, PostgreSQLParserWIDTH_BUCKET, PostgreSQLParserRANDOM, PostgreSQLParserSETSEED, PostgreSQLParserACOS, PostgreSQLParserACOSD, PostgreSQLParserASIN, PostgreSQLParserASIND, PostgreSQLParserATAN, PostgreSQLParserATAND, PostgreSQLParserATAN2, PostgreSQLParserATAN2D, PostgreSQLParserCOS, PostgreSQLParserCOSD, PostgreSQLParserCOT, PostgreSQLParserCOTD, PostgreSQLParserSIN, PostgreSQLParserSIND, PostgreSQLParserTAN, PostgreSQLParserTAND, PostgreSQLParserSINH, PostgreSQLParserCOSH, PostgreSQLParserTANH, PostgreSQLParserASINH, PostgreSQLParserACOSH, PostgreSQLParserATANH, PostgreSQLParserBIT_LENGTH, PostgreSQLParserCHAR_LENGTH, PostgreSQLParserCHARACTER_LENGTH, PostgreSQLParserLOWER, PostgreSQLParserOCTET_LENGTH, PostgreSQLParserUPPER, PostgreSQLParserASCII, PostgreSQLParserBTRIM, PostgreSQLParserCHR, PostgreSQLParserCONCAT, PostgreSQLParserCONCAT_WS, PostgreSQLParserFORMAT, PostgreSQLParserINITCAP, PostgreSQLParserLENGTH, PostgreSQLParserLPAD, PostgreSQLParserLTRIM, PostgreSQLParserMD5, PostgreSQLParserPARSE_IDENT, PostgreSQLParserPG_CLIENT_ENCODING, PostgreSQLParserQUOTE_IDENT, PostgreSQLParserQUOTE_LITERAL, PostgreSQLParserQUOTE_NULLABLE, PostgreSQLParserREGEXP_COUNT, PostgreSQLParserREGEXP_INSTR, PostgreSQLParserREGEXP_LIKE, PostgreSQLParserREGEXP_MATCH, PostgreSQLParserREGEXP_MATCHES, PostgreSQLParserREGEXP_REPLACE, PostgreSQLParserREGEXP_SPLIT_TO_ARRAY, PostgreSQLParserREGEXP_SPLIT_TO_TABLE, PostgreSQLParserREGEXP_SUBSTR, PostgreSQLParserREPEAT, PostgreSQLParserRPAD, PostgreSQLParserRTRIM, PostgreSQLParserSPLIT_PART, PostgreSQLParserSTARTS_WITH, PostgreSQLParserSTRING_TO_ARRAY, PostgreSQLParserSTRING_TO_TABLE, PostgreSQLParserSTRPOS, PostgreSQLParserSUBSTR, PostgreSQLParserTO_ASCII, PostgreSQLParserTO_HEX, PostgreSQLParserTRANSLATE, PostgreSQLParserUNISTR, PostgreSQLParserAGE, PostgreSQLParserCLOCK_TIMESTAMP, PostgreSQLParserDATE_BIN, PostgreSQLParserDATE_PART, PostgreSQLParserDATE_TRUNC, PostgreSQLParserISFINITE, PostgreSQLParserJUSTIFY_DAYS, PostgreSQLParserJUSTIFY_HOURS, PostgreSQLParserJUSTIFY_INTERVAL, PostgreSQLParserMAKE_DATE, PostgreSQLParserMAKE_INTERVAL, PostgreSQLParserMAKE_TIME, PostgreSQLParserMAKE_TIMESTAMP, PostgreSQLParserMAKE_TIMESTAMPTZ, PostgreSQLParserNOW, PostgreSQLParserSTATEMENT_TIMESTAMP, PostgreSQLParserTIMEOFDAY, PostgreSQLParserTRANSACTION_TIMESTAMP, PostgreSQLParserTO_TIMESTAMP, PostgreSQLParserTO_CHAR, PostgreSQLParserTO_DATE, PostgreSQLParserTO_NUMBER, PostgreSQLParserIdentifier, PostgreSQLParserQuotedIdentifier, PostgreSQLParserUnicodeQuotedIdentifier, PostgreSQLParserPLSQLVARIABLENAME, PostgreSQLParserPLSQLIDENTIFIER:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(10075)
			p.Colid()
		}

	default:
		p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IDecl_varnameContext is an interface to support dynamic dispatch.
type IDecl_varnameContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Any_identifier() IAny_identifierContext

	// IsDecl_varnameContext differentiates from other interfaces.
	IsDecl_varnameContext()
}

type Decl_varnameContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyDecl_varnameContext() *Decl_varnameContext {
	var p = new(Decl_varnameContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_decl_varname
	return p
}

func InitEmptyDecl_varnameContext(p *Decl_varnameContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_decl_varname
}

func (*Decl_varnameContext) IsDecl_varnameContext() {}

func NewDecl_varnameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Decl_varnameContext {
	var p = new(Decl_varnameContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_decl_varname

	return p
}

func (s *Decl_varnameContext) GetParser() antlr.Parser { return s.parser }

func (s *Decl_varnameContext) Any_identifier() IAny_identifierContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IAny_identifierContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IAny_identifierContext)
}

func (s *Decl_varnameContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Decl_varnameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Decl_varnameContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterDecl_varname(s)
	}
}

func (s *Decl_varnameContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitDecl_varname(s)
	}
}

func (s *Decl_varnameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitDecl_varname(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Decl_varname() (localctx IDecl_varnameContext) {
	localctx = NewDecl_varnameContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1436, PostgreSQLParserRULE_decl_varname)
	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(10078)
		p.Any_identifier()
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IDecl_constContext is an interface to support dynamic dispatch.
type IDecl_constContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	CONSTANT() antlr.TerminalNode

	// IsDecl_constContext differentiates from other interfaces.
	IsDecl_constContext()
}

type Decl_constContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyDecl_constContext() *Decl_constContext {
	var p = new(Decl_constContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_decl_const
	return p
}

func InitEmptyDecl_constContext(p *Decl_constContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_decl_const
}

func (*Decl_constContext) IsDecl_constContext() {}

func NewDecl_constContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Decl_constContext {
	var p = new(Decl_constContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_decl_const

	return p
}

func (s *Decl_constContext) GetParser() antlr.Parser { return s.parser }

func (s *Decl_constContext) CONSTANT() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCONSTANT, 0)
}

func (s *Decl_constContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Decl_constContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Decl_constContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterDecl_const(s)
	}
}

func (s *Decl_constContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitDecl_const(s)
	}
}

func (s *Decl_constContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitDecl_const(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Decl_const() (localctx IDecl_constContext) {
	localctx = NewDecl_constContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1438, PostgreSQLParserRULE_decl_const)
	p.SetState(10082)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 678, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(10081)
			p.Match(PostgreSQLParserCONSTANT)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case antlr.ATNInvalidAltNumber:
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IDecl_datatypeContext is an interface to support dynamic dispatch.
type IDecl_datatypeContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Typename() ITypenameContext

	// IsDecl_datatypeContext differentiates from other interfaces.
	IsDecl_datatypeContext()
}

type Decl_datatypeContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyDecl_datatypeContext() *Decl_datatypeContext {
	var p = new(Decl_datatypeContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_decl_datatype
	return p
}

func InitEmptyDecl_datatypeContext(p *Decl_datatypeContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_decl_datatype
}

func (*Decl_datatypeContext) IsDecl_datatypeContext() {}

func NewDecl_datatypeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Decl_datatypeContext {
	var p = new(Decl_datatypeContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_decl_datatype

	return p
}

func (s *Decl_datatypeContext) GetParser() antlr.Parser { return s.parser }

func (s *Decl_datatypeContext) Typename() ITypenameContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ITypenameContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ITypenameContext)
}

func (s *Decl_datatypeContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Decl_datatypeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Decl_datatypeContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterDecl_datatype(s)
	}
}

func (s *Decl_datatypeContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitDecl_datatype(s)
	}
}

func (s *Decl_datatypeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitDecl_datatype(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Decl_datatype() (localctx IDecl_datatypeContext) {
	localctx = NewDecl_datatypeContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1440, PostgreSQLParserRULE_decl_datatype)
	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(10084)
		p.Typename()
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IDecl_collateContext is an interface to support dynamic dispatch.
type IDecl_collateContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	COLLATE() antlr.TerminalNode
	Any_name() IAny_nameContext

	// IsDecl_collateContext differentiates from other interfaces.
	IsDecl_collateContext()
}

type Decl_collateContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyDecl_collateContext() *Decl_collateContext {
	var p = new(Decl_collateContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_decl_collate
	return p
}

func InitEmptyDecl_collateContext(p *Decl_collateContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_decl_collate
}

func (*Decl_collateContext) IsDecl_collateContext() {}

func NewDecl_collateContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Decl_collateContext {
	var p = new(Decl_collateContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_decl_collate

	return p
}

func (s *Decl_collateContext) GetParser() antlr.Parser { return s.parser }

func (s *Decl_collateContext) COLLATE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCOLLATE, 0)
}

func (s *Decl_collateContext) Any_name() IAny_nameContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IAny_nameContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IAny_nameContext)
}

func (s *Decl_collateContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Decl_collateContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Decl_collateContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterDecl_collate(s)
	}
}

func (s *Decl_collateContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitDecl_collate(s)
	}
}

func (s *Decl_collateContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitDecl_collate(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Decl_collate() (localctx IDecl_collateContext) {
	localctx = NewDecl_collateContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1442, PostgreSQLParserRULE_decl_collate)
	p.SetState(10089)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetTokenStream().LA(1) {
	case PostgreSQLParserSEMI, PostgreSQLParserEQUAL, PostgreSQLParserCOLON_EQUALS, PostgreSQLParserDEFAULT, PostgreSQLParserNOT:
		p.EnterOuterAlt(localctx, 1)

	case PostgreSQLParserCOLLATE:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(10087)
			p.Match(PostgreSQLParserCOLLATE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(10088)
			p.Any_name()
		}

	default:
		p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IDecl_notnullContext is an interface to support dynamic dispatch.
type IDecl_notnullContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	NOT() antlr.TerminalNode
	NULL_P() antlr.TerminalNode

	// IsDecl_notnullContext differentiates from other interfaces.
	IsDecl_notnullContext()
}

type Decl_notnullContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyDecl_notnullContext() *Decl_notnullContext {
	var p = new(Decl_notnullContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_decl_notnull
	return p
}

func InitEmptyDecl_notnullContext(p *Decl_notnullContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_decl_notnull
}

func (*Decl_notnullContext) IsDecl_notnullContext() {}

func NewDecl_notnullContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Decl_notnullContext {
	var p = new(Decl_notnullContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_decl_notnull

	return p
}

func (s *Decl_notnullContext) GetParser() antlr.Parser { return s.parser }

func (s *Decl_notnullContext) NOT() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserNOT, 0)
}

func (s *Decl_notnullContext) NULL_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserNULL_P, 0)
}

func (s *Decl_notnullContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Decl_notnullContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Decl_notnullContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterDecl_notnull(s)
	}
}

func (s *Decl_notnullContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitDecl_notnull(s)
	}
}

func (s *Decl_notnullContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitDecl_notnull(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Decl_notnull() (localctx IDecl_notnullContext) {
	localctx = NewDecl_notnullContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1444, PostgreSQLParserRULE_decl_notnull)
	p.SetState(10094)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetTokenStream().LA(1) {
	case PostgreSQLParserSEMI, PostgreSQLParserEQUAL, PostgreSQLParserCOLON_EQUALS, PostgreSQLParserDEFAULT:
		p.EnterOuterAlt(localctx, 1)

	case PostgreSQLParserNOT:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(10092)
			p.Match(PostgreSQLParserNOT)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(10093)
			p.Match(PostgreSQLParserNULL_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	default:
		p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IDecl_defvalContext is an interface to support dynamic dispatch.
type IDecl_defvalContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Decl_defkey() IDecl_defkeyContext
	Sql_expression() ISql_expressionContext

	// IsDecl_defvalContext differentiates from other interfaces.
	IsDecl_defvalContext()
}

type Decl_defvalContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyDecl_defvalContext() *Decl_defvalContext {
	var p = new(Decl_defvalContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_decl_defval
	return p
}

func InitEmptyDecl_defvalContext(p *Decl_defvalContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_decl_defval
}

func (*Decl_defvalContext) IsDecl_defvalContext() {}

func NewDecl_defvalContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Decl_defvalContext {
	var p = new(Decl_defvalContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_decl_defval

	return p
}

func (s *Decl_defvalContext) GetParser() antlr.Parser { return s.parser }

func (s *Decl_defvalContext) Decl_defkey() IDecl_defkeyContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IDecl_defkeyContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IDecl_defkeyContext)
}

func (s *Decl_defvalContext) Sql_expression() ISql_expressionContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ISql_expressionContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ISql_expressionContext)
}

func (s *Decl_defvalContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Decl_defvalContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Decl_defvalContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterDecl_defval(s)
	}
}

func (s *Decl_defvalContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitDecl_defval(s)
	}
}

func (s *Decl_defvalContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitDecl_defval(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Decl_defval() (localctx IDecl_defvalContext) {
	localctx = NewDecl_defvalContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1446, PostgreSQLParserRULE_decl_defval)
	p.SetState(10100)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetTokenStream().LA(1) {
	case PostgreSQLParserSEMI:
		p.EnterOuterAlt(localctx, 1)

	case PostgreSQLParserEQUAL, PostgreSQLParserCOLON_EQUALS, PostgreSQLParserDEFAULT:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(10097)
			p.Decl_defkey()
		}
		{
			p.SetState(10098)
			p.Sql_expression()
		}

	default:
		p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IDecl_defkeyContext is an interface to support dynamic dispatch.
type IDecl_defkeyContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Assign_operator() IAssign_operatorContext
	DEFAULT() antlr.TerminalNode

	// IsDecl_defkeyContext differentiates from other interfaces.
	IsDecl_defkeyContext()
}

type Decl_defkeyContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyDecl_defkeyContext() *Decl_defkeyContext {
	var p = new(Decl_defkeyContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_decl_defkey
	return p
}

func InitEmptyDecl_defkeyContext(p *Decl_defkeyContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_decl_defkey
}

func (*Decl_defkeyContext) IsDecl_defkeyContext() {}

func NewDecl_defkeyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Decl_defkeyContext {
	var p = new(Decl_defkeyContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_decl_defkey

	return p
}

func (s *Decl_defkeyContext) GetParser() antlr.Parser { return s.parser }

func (s *Decl_defkeyContext) Assign_operator() IAssign_operatorContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IAssign_operatorContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IAssign_operatorContext)
}

func (s *Decl_defkeyContext) DEFAULT() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserDEFAULT, 0)
}

func (s *Decl_defkeyContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Decl_defkeyContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Decl_defkeyContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterDecl_defkey(s)
	}
}

func (s *Decl_defkeyContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitDecl_defkey(s)
	}
}

func (s *Decl_defkeyContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitDecl_defkey(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Decl_defkey() (localctx IDecl_defkeyContext) {
	localctx = NewDecl_defkeyContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1448, PostgreSQLParserRULE_decl_defkey)
	p.SetState(10104)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetTokenStream().LA(1) {
	case PostgreSQLParserEQUAL, PostgreSQLParserCOLON_EQUALS:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(10102)
			p.Assign_operator()
		}

	case PostgreSQLParserDEFAULT:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(10103)
			p.Match(PostgreSQLParserDEFAULT)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	default:
		p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IAssign_operatorContext is an interface to support dynamic dispatch.
type IAssign_operatorContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	EQUAL() antlr.TerminalNode
	COLON_EQUALS() antlr.TerminalNode

	// IsAssign_operatorContext differentiates from other interfaces.
	IsAssign_operatorContext()
}

type Assign_operatorContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyAssign_operatorContext() *Assign_operatorContext {
	var p = new(Assign_operatorContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_assign_operator
	return p
}

func InitEmptyAssign_operatorContext(p *Assign_operatorContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_assign_operator
}

func (*Assign_operatorContext) IsAssign_operatorContext() {}

func NewAssign_operatorContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Assign_operatorContext {
	var p = new(Assign_operatorContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_assign_operator

	return p
}

func (s *Assign_operatorContext) GetParser() antlr.Parser { return s.parser }

func (s *Assign_operatorContext) EQUAL() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserEQUAL, 0)
}

func (s *Assign_operatorContext) COLON_EQUALS() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCOLON_EQUALS, 0)
}

func (s *Assign_operatorContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Assign_operatorContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Assign_operatorContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterAssign_operator(s)
	}
}

func (s *Assign_operatorContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitAssign_operator(s)
	}
}

func (s *Assign_operatorContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitAssign_operator(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Assign_operator() (localctx IAssign_operatorContext) {
	localctx = NewAssign_operatorContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1450, PostgreSQLParserRULE_assign_operator)
	var _la int

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(10106)
		_la = p.GetTokenStream().LA(1)

		if !(_la == PostgreSQLParserEQUAL || _la == PostgreSQLParserCOLON_EQUALS) {
			p.GetErrorHandler().RecoverInline(p)
		} else {
			p.GetErrorHandler().ReportMatch(p)
			p.Consume()
		}
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IProc_sectContext is an interface to support dynamic dispatch.
type IProc_sectContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	AllProc_stmt() []IProc_stmtContext
	Proc_stmt(i int) IProc_stmtContext

	// IsProc_sectContext differentiates from other interfaces.
	IsProc_sectContext()
}

type Proc_sectContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyProc_sectContext() *Proc_sectContext {
	var p = new(Proc_sectContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_proc_sect
	return p
}

func InitEmptyProc_sectContext(p *Proc_sectContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_proc_sect
}

func (*Proc_sectContext) IsProc_sectContext() {}

func NewProc_sectContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Proc_sectContext {
	var p = new(Proc_sectContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_proc_sect

	return p
}

func (s *Proc_sectContext) GetParser() antlr.Parser { return s.parser }

func (s *Proc_sectContext) AllProc_stmt() []IProc_stmtContext {
	children := s.GetChildren()
	len := 0
	for _, ctx := range children {
		if _, ok := ctx.(IProc_stmtContext); ok {
			len++
		}
	}

	tst := make([]IProc_stmtContext, len)
	i := 0
	for _, ctx := range children {
		if t, ok := ctx.(IProc_stmtContext); ok {
			tst[i] = t.(IProc_stmtContext)
			i++
		}
	}

	return tst
}

func (s *Proc_sectContext) Proc_stmt(i int) IProc_stmtContext {
	var t antlr.RuleContext
	j := 0
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IProc_stmtContext); ok {
			if j == i {
				t = ctx.(antlr.RuleContext)
				break
			}
			j++
		}
	}

	if t == nil {
		return nil
	}

	return t.(IProc_stmtContext)
}

func (s *Proc_sectContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Proc_sectContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Proc_sectContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterProc_sect(s)
	}
}

func (s *Proc_sectContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitProc_sect(s)
	}
}

func (s *Proc_sectContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitProc_sect(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Proc_sect() (localctx IProc_sectContext) {
	localctx = NewProc_sectContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1452, PostgreSQLParserRULE_proc_sect)
	var _alt int

	p.EnterOuterAlt(localctx, 1)
	p.SetState(10111)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}
	_alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 683, p.GetParserRuleContext())
	if p.HasError() {
		goto errorExit
	}
	for _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
		if _alt == 1 {
			{
				p.SetState(10108)
				p.Proc_stmt()
			}

		}
		p.SetState(10113)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}
		_alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 683, p.GetParserRuleContext())
		if p.HasError() {
			goto errorExit
		}
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IProc_stmtContext is an interface to support dynamic dispatch.
type IProc_stmtContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Pl_block() IPl_blockContext
	SEMI() antlr.TerminalNode
	Stmt_return() IStmt_returnContext
	Stmt_raise() IStmt_raiseContext
	Stmt_assign() IStmt_assignContext
	Stmt_if() IStmt_ifContext
	Stmt_case() IStmt_caseContext
	Stmt_loop() IStmt_loopContext
	Stmt_while() IStmt_whileContext
	Stmt_for() IStmt_forContext
	Stmt_foreach_a() IStmt_foreach_aContext
	Stmt_exit() IStmt_exitContext
	Stmt_assert() IStmt_assertContext
	Stmt_execsql() IStmt_execsqlContext
	Stmt_dynexecute() IStmt_dynexecuteContext
	Stmt_perform() IStmt_performContext
	Stmt_call() IStmt_callContext
	Stmt_getdiag() IStmt_getdiagContext
	Stmt_open() IStmt_openContext
	Stmt_fetch() IStmt_fetchContext
	Stmt_move() IStmt_moveContext
	Stmt_close() IStmt_closeContext
	Stmt_null() IStmt_nullContext
	Stmt_commit() IStmt_commitContext
	Stmt_rollback() IStmt_rollbackContext
	Stmt_set() IStmt_setContext

	// IsProc_stmtContext differentiates from other interfaces.
	IsProc_stmtContext()
}

type Proc_stmtContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyProc_stmtContext() *Proc_stmtContext {
	var p = new(Proc_stmtContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_proc_stmt
	return p
}

func InitEmptyProc_stmtContext(p *Proc_stmtContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_proc_stmt
}

func (*Proc_stmtContext) IsProc_stmtContext() {}

func NewProc_stmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Proc_stmtContext {
	var p = new(Proc_stmtContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_proc_stmt

	return p
}

func (s *Proc_stmtContext) GetParser() antlr.Parser { return s.parser }

func (s *Proc_stmtContext) Pl_block() IPl_blockContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IPl_blockContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IPl_blockContext)
}

func (s *Proc_stmtContext) SEMI() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserSEMI, 0)
}

func (s *Proc_stmtContext) Stmt_return() IStmt_returnContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IStmt_returnContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IStmt_returnContext)
}

func (s *Proc_stmtContext) Stmt_raise() IStmt_raiseContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IStmt_raiseContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IStmt_raiseContext)
}

func (s *Proc_stmtContext) Stmt_assign() IStmt_assignContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IStmt_assignContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IStmt_assignContext)
}

func (s *Proc_stmtContext) Stmt_if() IStmt_ifContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IStmt_ifContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IStmt_ifContext)
}

func (s *Proc_stmtContext) Stmt_case() IStmt_caseContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IStmt_caseContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IStmt_caseContext)
}

func (s *Proc_stmtContext) Stmt_loop() IStmt_loopContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IStmt_loopContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IStmt_loopContext)
}

func (s *Proc_stmtContext) Stmt_while() IStmt_whileContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IStmt_whileContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IStmt_whileContext)
}

func (s *Proc_stmtContext) Stmt_for() IStmt_forContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IStmt_forContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IStmt_forContext)
}

func (s *Proc_stmtContext) Stmt_foreach_a() IStmt_foreach_aContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IStmt_foreach_aContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IStmt_foreach_aContext)
}

func (s *Proc_stmtContext) Stmt_exit() IStmt_exitContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IStmt_exitContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IStmt_exitContext)
}

func (s *Proc_stmtContext) Stmt_assert() IStmt_assertContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IStmt_assertContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IStmt_assertContext)
}

func (s *Proc_stmtContext) Stmt_execsql() IStmt_execsqlContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IStmt_execsqlContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IStmt_execsqlContext)
}

func (s *Proc_stmtContext) Stmt_dynexecute() IStmt_dynexecuteContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IStmt_dynexecuteContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IStmt_dynexecuteContext)
}

func (s *Proc_stmtContext) Stmt_perform() IStmt_performContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IStmt_performContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IStmt_performContext)
}

func (s *Proc_stmtContext) Stmt_call() IStmt_callContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IStmt_callContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IStmt_callContext)
}

func (s *Proc_stmtContext) Stmt_getdiag() IStmt_getdiagContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IStmt_getdiagContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IStmt_getdiagContext)
}

func (s *Proc_stmtContext) Stmt_open() IStmt_openContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IStmt_openContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IStmt_openContext)
}

func (s *Proc_stmtContext) Stmt_fetch() IStmt_fetchContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IStmt_fetchContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IStmt_fetchContext)
}

func (s *Proc_stmtContext) Stmt_move() IStmt_moveContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IStmt_moveContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IStmt_moveContext)
}

func (s *Proc_stmtContext) Stmt_close() IStmt_closeContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IStmt_closeContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IStmt_closeContext)
}

func (s *Proc_stmtContext) Stmt_null() IStmt_nullContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IStmt_nullContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IStmt_nullContext)
}

func (s *Proc_stmtContext) Stmt_commit() IStmt_commitContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IStmt_commitContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IStmt_commitContext)
}

func (s *Proc_stmtContext) Stmt_rollback() IStmt_rollbackContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IStmt_rollbackContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IStmt_rollbackContext)
}

func (s *Proc_stmtContext) Stmt_set() IStmt_setContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IStmt_setContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IStmt_setContext)
}

func (s *Proc_stmtContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Proc_stmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Proc_stmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterProc_stmt(s)
	}
}

func (s *Proc_stmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitProc_stmt(s)
	}
}

func (s *Proc_stmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitProc_stmt(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Proc_stmt() (localctx IProc_stmtContext) {
	localctx = NewProc_stmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1454, PostgreSQLParserRULE_proc_stmt)
	p.SetState(10141)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 684, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(10114)
			p.Pl_block()
		}
		{
			p.SetState(10115)
			p.Match(PostgreSQLParserSEMI)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(10117)
			p.Stmt_return()
		}

	case 3:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(10118)
			p.Stmt_raise()
		}

	case 4:
		p.EnterOuterAlt(localctx, 4)
		{
			p.SetState(10119)
			p.Stmt_assign()
		}

	case 5:
		p.EnterOuterAlt(localctx, 5)
		{
			p.SetState(10120)
			p.Stmt_if()
		}

	case 6:
		p.EnterOuterAlt(localctx, 6)
		{
			p.SetState(10121)
			p.Stmt_case()
		}

	case 7:
		p.EnterOuterAlt(localctx, 7)
		{
			p.SetState(10122)
			p.Stmt_loop()
		}

	case 8:
		p.EnterOuterAlt(localctx, 8)
		{
			p.SetState(10123)
			p.Stmt_while()
		}

	case 9:
		p.EnterOuterAlt(localctx, 9)
		{
			p.SetState(10124)
			p.Stmt_for()
		}

	case 10:
		p.EnterOuterAlt(localctx, 10)
		{
			p.SetState(10125)
			p.Stmt_foreach_a()
		}

	case 11:
		p.EnterOuterAlt(localctx, 11)
		{
			p.SetState(10126)
			p.Stmt_exit()
		}

	case 12:
		p.EnterOuterAlt(localctx, 12)
		{
			p.SetState(10127)
			p.Stmt_assert()
		}

	case 13:
		p.EnterOuterAlt(localctx, 13)
		{
			p.SetState(10128)
			p.Stmt_execsql()
		}

	case 14:
		p.EnterOuterAlt(localctx, 14)
		{
			p.SetState(10129)
			p.Stmt_dynexecute()
		}

	case 15:
		p.EnterOuterAlt(localctx, 15)
		{
			p.SetState(10130)
			p.Stmt_perform()
		}

	case 16:
		p.EnterOuterAlt(localctx, 16)
		{
			p.SetState(10131)
			p.Stmt_call()
		}

	case 17:
		p.EnterOuterAlt(localctx, 17)
		{
			p.SetState(10132)
			p.Stmt_getdiag()
		}

	case 18:
		p.EnterOuterAlt(localctx, 18)
		{
			p.SetState(10133)
			p.Stmt_open()
		}

	case 19:
		p.EnterOuterAlt(localctx, 19)
		{
			p.SetState(10134)
			p.Stmt_fetch()
		}

	case 20:
		p.EnterOuterAlt(localctx, 20)
		{
			p.SetState(10135)
			p.Stmt_move()
		}

	case 21:
		p.EnterOuterAlt(localctx, 21)
		{
			p.SetState(10136)
			p.Stmt_close()
		}

	case 22:
		p.EnterOuterAlt(localctx, 22)
		{
			p.SetState(10137)
			p.Stmt_null()
		}

	case 23:
		p.EnterOuterAlt(localctx, 23)
		{
			p.SetState(10138)
			p.Stmt_commit()
		}

	case 24:
		p.EnterOuterAlt(localctx, 24)
		{
			p.SetState(10139)
			p.Stmt_rollback()
		}

	case 25:
		p.EnterOuterAlt(localctx, 25)
		{
			p.SetState(10140)
			p.Stmt_set()
		}

	case antlr.ATNInvalidAltNumber:
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IStmt_performContext is an interface to support dynamic dispatch.
type IStmt_performContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	PERFORM() antlr.TerminalNode
	Expr_until_semi() IExpr_until_semiContext
	SEMI() antlr.TerminalNode

	// IsStmt_performContext differentiates from other interfaces.
	IsStmt_performContext()
}

type Stmt_performContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyStmt_performContext() *Stmt_performContext {
	var p = new(Stmt_performContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_stmt_perform
	return p
}

func InitEmptyStmt_performContext(p *Stmt_performContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_stmt_perform
}

func (*Stmt_performContext) IsStmt_performContext() {}

func NewStmt_performContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Stmt_performContext {
	var p = new(Stmt_performContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_stmt_perform

	return p
}

func (s *Stmt_performContext) GetParser() antlr.Parser { return s.parser }

func (s *Stmt_performContext) PERFORM() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserPERFORM, 0)
}

func (s *Stmt_performContext) Expr_until_semi() IExpr_until_semiContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IExpr_until_semiContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IExpr_until_semiContext)
}

func (s *Stmt_performContext) SEMI() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserSEMI, 0)
}

func (s *Stmt_performContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Stmt_performContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Stmt_performContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterStmt_perform(s)
	}
}

func (s *Stmt_performContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitStmt_perform(s)
	}
}

func (s *Stmt_performContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitStmt_perform(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Stmt_perform() (localctx IStmt_performContext) {
	localctx = NewStmt_performContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1456, PostgreSQLParserRULE_stmt_perform)
	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(10143)
		p.Match(PostgreSQLParserPERFORM)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(10144)
		p.Expr_until_semi()
	}
	{
		p.SetState(10145)
		p.Match(PostgreSQLParserSEMI)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IStmt_callContext is an interface to support dynamic dispatch.
type IStmt_callContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	CALL() antlr.TerminalNode
	Any_identifier() IAny_identifierContext
	OPEN_PAREN() antlr.TerminalNode
	Opt_expr_list() IOpt_expr_listContext
	CLOSE_PAREN() antlr.TerminalNode
	SEMI() antlr.TerminalNode
	DO() antlr.TerminalNode

	// IsStmt_callContext differentiates from other interfaces.
	IsStmt_callContext()
}

type Stmt_callContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyStmt_callContext() *Stmt_callContext {
	var p = new(Stmt_callContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_stmt_call
	return p
}

func InitEmptyStmt_callContext(p *Stmt_callContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_stmt_call
}

func (*Stmt_callContext) IsStmt_callContext() {}

func NewStmt_callContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Stmt_callContext {
	var p = new(Stmt_callContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_stmt_call

	return p
}

func (s *Stmt_callContext) GetParser() antlr.Parser { return s.parser }

func (s *Stmt_callContext) CALL() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCALL, 0)
}

func (s *Stmt_callContext) Any_identifier() IAny_identifierContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IAny_identifierContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IAny_identifierContext)
}

func (s *Stmt_callContext) OPEN_PAREN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserOPEN_PAREN, 0)
}

func (s *Stmt_callContext) Opt_expr_list() IOpt_expr_listContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOpt_expr_listContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOpt_expr_listContext)
}

func (s *Stmt_callContext) CLOSE_PAREN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCLOSE_PAREN, 0)
}

func (s *Stmt_callContext) SEMI() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserSEMI, 0)
}

func (s *Stmt_callContext) DO() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserDO, 0)
}

func (s *Stmt_callContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Stmt_callContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Stmt_callContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterStmt_call(s)
	}
}

func (s *Stmt_callContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitStmt_call(s)
	}
}

func (s *Stmt_callContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitStmt_call(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Stmt_call() (localctx IStmt_callContext) {
	localctx = NewStmt_callContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1458, PostgreSQLParserRULE_stmt_call)
	p.SetState(10161)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetTokenStream().LA(1) {
	case PostgreSQLParserCALL:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(10147)
			p.Match(PostgreSQLParserCALL)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(10148)
			p.Any_identifier()
		}
		{
			p.SetState(10149)
			p.Match(PostgreSQLParserOPEN_PAREN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(10150)
			p.Opt_expr_list()
		}
		{
			p.SetState(10151)
			p.Match(PostgreSQLParserCLOSE_PAREN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(10152)
			p.Match(PostgreSQLParserSEMI)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case PostgreSQLParserDO:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(10154)
			p.Match(PostgreSQLParserDO)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(10155)
			p.Any_identifier()
		}
		{
			p.SetState(10156)
			p.Match(PostgreSQLParserOPEN_PAREN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(10157)
			p.Opt_expr_list()
		}
		{
			p.SetState(10158)
			p.Match(PostgreSQLParserCLOSE_PAREN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(10159)
			p.Match(PostgreSQLParserSEMI)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	default:
		p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IOpt_expr_listContext is an interface to support dynamic dispatch.
type IOpt_expr_listContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Expr_list() IExpr_listContext

	// IsOpt_expr_listContext differentiates from other interfaces.
	IsOpt_expr_listContext()
}

type Opt_expr_listContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyOpt_expr_listContext() *Opt_expr_listContext {
	var p = new(Opt_expr_listContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opt_expr_list
	return p
}

func InitEmptyOpt_expr_listContext(p *Opt_expr_listContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opt_expr_list
}

func (*Opt_expr_listContext) IsOpt_expr_listContext() {}

func NewOpt_expr_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_expr_listContext {
	var p = new(Opt_expr_listContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_opt_expr_list

	return p
}

func (s *Opt_expr_listContext) GetParser() antlr.Parser { return s.parser }

func (s *Opt_expr_listContext) Expr_list() IExpr_listContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IExpr_listContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IExpr_listContext)
}

func (s *Opt_expr_listContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Opt_expr_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Opt_expr_listContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterOpt_expr_list(s)
	}
}

func (s *Opt_expr_listContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitOpt_expr_list(s)
	}
}

func (s *Opt_expr_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitOpt_expr_list(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Opt_expr_list() (localctx IOpt_expr_listContext) {
	localctx = NewOpt_expr_listContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1460, PostgreSQLParserRULE_opt_expr_list)
	p.SetState(10165)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetTokenStream().LA(1) {
	case PostgreSQLParserCLOSE_PAREN:
		p.EnterOuterAlt(localctx, 1)

	case PostgreSQLParserOPEN_PAREN, PostgreSQLParserPLUS, PostgreSQLParserMINUS, PostgreSQLParserPARAM, PostgreSQLParserOperator, PostgreSQLParserAND, PostgreSQLParserARRAY, PostgreSQLParserCASE, PostgreSQLParserCAST, PostgreSQLParserCOLLATE, PostgreSQLParserCOLUMN, PostgreSQLParserCONSTRAINT, PostgreSQLParserCURRENT_CATALOG, PostgreSQLParserCURRENT_DATE, PostgreSQLParserCURRENT_ROLE, PostgreSQLParserCURRENT_TIME, PostgreSQLParserCURRENT_TIMESTAMP, PostgreSQLParserCURRENT_USER, PostgreSQLParserDEFAULT, PostgreSQLParserDO, PostgreSQLParserFALSE_P, PostgreSQLParserFETCH, PostgreSQLParserLOCALTIME, PostgreSQLParserLOCALTIMESTAMP, PostgreSQLParserNOT, PostgreSQLParserNULL_P, PostgreSQLParserSESSION_USER, PostgreSQLParserTABLE, PostgreSQLParserTRUE_P, PostgreSQLParserUNIQUE, PostgreSQLParserUSER, PostgreSQLParserAUTHORIZATION, PostgreSQLParserBINARY, PostgreSQLParserCOLLATION, PostgreSQLParserCONCURRENTLY, PostgreSQLParserCROSS, PostgreSQLParserCURRENT_SCHEMA, PostgreSQLParserFREEZE, PostgreSQLParserFULL, PostgreSQLParserILIKE, PostgreSQLParserINNER_P, PostgreSQLParserIS, PostgreSQLParserISNULL, PostgreSQLParserJOIN, PostgreSQLParserLEFT, PostgreSQLParserLIKE, PostgreSQLParserNATURAL, PostgreSQLParserNOTNULL, PostgreSQLParserOUTER_P, PostgreSQLParserOVER, PostgreSQLParserOVERLAPS, PostgreSQLParserRIGHT, PostgreSQLParserSIMILAR, PostgreSQLParserVERBOSE, PostgreSQLParserABORT_P, PostgreSQLParserABSOLUTE_P, PostgreSQLParserACCESS, PostgreSQLParserACTION, PostgreSQLParserADD_P, PostgreSQLParserADMIN, PostgreSQLParserAFTER, PostgreSQLParserAGGREGATE, PostgreSQLParserALSO, PostgreSQLParserALTER, PostgreSQLParserALWAYS, PostgreSQLParserASSERTION, PostgreSQLParserASSIGNMENT, PostgreSQLParserAT, PostgreSQLParserATTRIBUTE, PostgreSQLParserBACKWARD, PostgreSQLParserBEFORE, PostgreSQLParserBEGIN_P, PostgreSQLParserBY, PostgreSQLParserCACHE, PostgreSQLParserCALLED, PostgreSQLParserCASCADE, PostgreSQLParserCASCADED, PostgreSQLParserCATALOG, PostgreSQLParserCHAIN, PostgreSQLParserCHARACTERISTICS, PostgreSQLParserCHECKPOINT, PostgreSQLParserCLASS, PostgreSQLParserCLOSE, PostgreSQLParserCLUSTER, PostgreSQLParserCOMMENT, PostgreSQLParserCOMMENTS, PostgreSQLParserCOMMIT, PostgreSQLParserCOMMITTED, PostgreSQLParserCONFIGURATION, PostgreSQLParserCONNECTION, PostgreSQLParserCONSTRAINTS, PostgreSQLParserCONTENT_P, PostgreSQLParserCONTINUE_P, PostgreSQLParserCONVERSION_P, PostgreSQLParserCOPY, PostgreSQLParserCOST, PostgreSQLParserCSV, PostgreSQLParserCURSOR, PostgreSQLParserCYCLE, PostgreSQLParserDATA_P, PostgreSQLParserDATABASE, PostgreSQLParserDAY_P, PostgreSQLParserDEALLOCATE, PostgreSQLParserDECLARE, PostgreSQLParserDEFAULTS, PostgreSQLParserDEFERRED, PostgreSQLParserDEFINER, PostgreSQLParserDELETE_P, PostgreSQLParserDELIMITER, PostgreSQLParserDELIMITERS, PostgreSQLParserDICTIONARY, PostgreSQLParserDISABLE_P, PostgreSQLParserDISCARD, PostgreSQLParserDOCUMENT_P, PostgreSQLParserDOMAIN_P, PostgreSQLParserDOUBLE_P, PostgreSQLParserDROP, PostgreSQLParserEACH, PostgreSQLParserENABLE_P, PostgreSQLParserENCODING, PostgreSQLParserENCRYPTED, PostgreSQLParserENUM_P, PostgreSQLParserESCAPE, PostgreSQLParserEVENT, PostgreSQLParserEXCLUDE, PostgreSQLParserEXCLUDING, PostgreSQLParserEXCLUSIVE, PostgreSQLParserEXECUTE, PostgreSQLParserEXPLAIN, PostgreSQLParserEXTENSION, PostgreSQLParserEXTERNAL, PostgreSQLParserFAMILY, PostgreSQLParserFIRST_P, PostgreSQLParserFOLLOWING, PostgreSQLParserFORCE, PostgreSQLParserFORWARD, PostgreSQLParserFUNCTION, PostgreSQLParserFUNCTIONS, PostgreSQLParserGLOBAL, PostgreSQLParserGRANTED, PostgreSQLParserHANDLER, PostgreSQLParserHEADER_P, PostgreSQLParserHOLD, PostgreSQLParserHOUR_P, PostgreSQLParserIDENTITY_P, PostgreSQLParserIF_P, PostgreSQLParserIMMEDIATE, PostgreSQLParserIMMUTABLE, PostgreSQLParserIMPLICIT_P, PostgreSQLParserINCLUDING, PostgreSQLParserINCREMENT, PostgreSQLParserINDEX, PostgreSQLParserINDEXES, PostgreSQLParserINHERIT, PostgreSQLParserINHERITS, PostgreSQLParserINLINE_P, PostgreSQLParserINSENSITIVE, PostgreSQLParserINSERT, PostgreSQLParserINSTEAD, PostgreSQLParserINVOKER, PostgreSQLParserISOLATION, PostgreSQLParserKEY, PostgreSQLParserLABEL, PostgreSQLParserLANGUAGE, PostgreSQLParserLARGE_P, PostgreSQLParserLAST_P, PostgreSQLParserLEAKPROOF, PostgreSQLParserLEVEL, PostgreSQLParserLISTEN, PostgreSQLParserLOAD, PostgreSQLParserLOCAL, PostgreSQLParserLOCATION, PostgreSQLParserLOCK_P, PostgreSQLParserMAPPING, PostgreSQLParserMATCH, PostgreSQLParserMATERIALIZED, PostgreSQLParserMAXVALUE, PostgreSQLParserMINUTE_P, PostgreSQLParserMINVALUE, PostgreSQLParserMODE, PostgreSQLParserMONTH_P, PostgreSQLParserMOVE, PostgreSQLParserNAME_P, PostgreSQLParserNAMES, PostgreSQLParserNEXT, PostgreSQLParserNO, PostgreSQLParserNOTHING, PostgreSQLParserNOTIFY, PostgreSQLParserNOWAIT, PostgreSQLParserNULLS_P, PostgreSQLParserOBJECT_P, PostgreSQLParserOF, PostgreSQLParserOFF, PostgreSQLParserOIDS, PostgreSQLParserOPERATOR, PostgreSQLParserOPTION, PostgreSQLParserOPTIONS, PostgreSQLParserOWNED, PostgreSQLParserOWNER, PostgreSQLParserPARSER, PostgreSQLParserPARTIAL, PostgreSQLParserPARTITION, PostgreSQLParserPASSING, PostgreSQLParserPASSWORD, PostgreSQLParserPLANS, PostgreSQLParserPRECEDING, PostgreSQLParserPREPARE, PostgreSQLParserPREPARED, PostgreSQLParserPRESERVE, PostgreSQLParserPRIOR, PostgreSQLParserPRIVILEGES, PostgreSQLParserPROCEDURAL, PostgreSQLParserPROCEDURE, PostgreSQLParserPROGRAM, PostgreSQLParserQUOTE, PostgreSQLParserRANGE, PostgreSQLParserREAD, PostgreSQLParserREASSIGN, PostgreSQLParserRECHECK, PostgreSQLParserRECURSIVE, PostgreSQLParserREF, PostgreSQLParserREFRESH, PostgreSQLParserREINDEX, PostgreSQLParserRELATIVE_P, PostgreSQLParserRELEASE, PostgreSQLParserRENAME, PostgreSQLParserREPEATABLE, PostgreSQLParserREPLACE, PostgreSQLParserREPLICA, PostgreSQLParserRESET, PostgreSQLParserRESTART, PostgreSQLParserRESTRICT, PostgreSQLParserRETURNS, PostgreSQLParserREVOKE, PostgreSQLParserROLE, PostgreSQLParserROLLBACK, PostgreSQLParserROWS, PostgreSQLParserRULE, PostgreSQLParserSAVEPOINT, PostgreSQLParserSCHEMA, PostgreSQLParserSCROLL, PostgreSQLParserSEARCH, PostgreSQLParserSECOND_P, PostgreSQLParserSECURITY, PostgreSQLParserSEQUENCE, PostgreSQLParserSEQUENCES, PostgreSQLParserSERIALIZABLE, PostgreSQLParserSERVER, PostgreSQLParserSESSION, PostgreSQLParserSET, PostgreSQLParserSHARE, PostgreSQLParserSHOW, PostgreSQLParserSIMPLE, PostgreSQLParserSNAPSHOT, PostgreSQLParserSTABLE, PostgreSQLParserSTANDALONE_P, PostgreSQLParserSTART, PostgreSQLParserSTATEMENT, PostgreSQLParserSTATISTICS, PostgreSQLParserSTDIN, PostgreSQLParserSTDOUT, PostgreSQLParserSTORAGE, PostgreSQLParserSTRICT_P, PostgreSQLParserSTRIP_P, PostgreSQLParserSYSID, PostgreSQLParserSYSTEM_P, PostgreSQLParserTABLES, PostgreSQLParserTABLESPACE, PostgreSQLParserTEMP, PostgreSQLParserTEMPLATE, PostgreSQLParserTEMPORARY, PostgreSQLParserTEXT_P, PostgreSQLParserTRANSACTION, PostgreSQLParserTRIGGER, PostgreSQLParserTRUNCATE, PostgreSQLParserTRUSTED, PostgreSQLParserTYPE_P, PostgreSQLParserTYPES_P, PostgreSQLParserUNBOUNDED, PostgreSQLParserUNCOMMITTED, PostgreSQLParserUNENCRYPTED, PostgreSQLParserUNKNOWN, PostgreSQLParserUNLISTEN, PostgreSQLParserUNLOGGED, PostgreSQLParserUNTIL, PostgreSQLParserUPDATE, PostgreSQLParserVACUUM, PostgreSQLParserVALID, PostgreSQLParserVALIDATE, PostgreSQLParserVALIDATOR, PostgreSQLParserVARYING, PostgreSQLParserVERSION_P, PostgreSQLParserVIEW, PostgreSQLParserVOLATILE, PostgreSQLParserWHITESPACE_P, PostgreSQLParserWITHOUT, PostgreSQLParserWORK, PostgreSQLParserWRAPPER, PostgreSQLParserWRITE, PostgreSQLParserXML_P, PostgreSQLParserYEAR_P, PostgreSQLParserYES_P, PostgreSQLParserZONE, PostgreSQLParserBETWEEN, PostgreSQLParserBIGINT, PostgreSQLParserBIT, PostgreSQLParserBOOLEAN_P, PostgreSQLParserCHAR_P, PostgreSQLParserCHARACTER, PostgreSQLParserCOALESCE, PostgreSQLParserDEC, PostgreSQLParserDECIMAL_P, PostgreSQLParserEXISTS, PostgreSQLParserEXTRACT, PostgreSQLParserFLOAT_P, PostgreSQLParserGREATEST, PostgreSQLParserINOUT, PostgreSQLParserINT_P, PostgreSQLParserINTEGER, PostgreSQLParserINTERVAL, PostgreSQLParserLEAST, PostgreSQLParserNATIONAL, PostgreSQLParserNCHAR, PostgreSQLParserNONE, PostgreSQLParserNULLIF, PostgreSQLParserNUMERIC, PostgreSQLParserOVERLAY, PostgreSQLParserPOSITION, PostgreSQLParserPRECISION, PostgreSQLParserREAL, PostgreSQLParserROW, PostgreSQLParserSETOF, PostgreSQLParserSMALLINT, PostgreSQLParserSUBSTRING, PostgreSQLParserTIME, PostgreSQLParserTIMESTAMP, PostgreSQLParserTREAT, PostgreSQLParserTRIM, PostgreSQLParserVALUES, PostgreSQLParserVARCHAR, PostgreSQLParserXMLATTRIBUTES, PostgreSQLParserXMLCOMMENT, PostgreSQLParserXMLAGG, PostgreSQLParserXML_IS_WELL_FORMED, PostgreSQLParserXML_IS_WELL_FORMED_DOCUMENT, PostgreSQLParserXML_IS_WELL_FORMED_CONTENT, PostgreSQLParserXPATH, PostgreSQLParserXPATH_EXISTS, PostgreSQLParserXMLCONCAT, PostgreSQLParserXMLELEMENT, PostgreSQLParserXMLEXISTS, PostgreSQLParserXMLFOREST, PostgreSQLParserXMLPARSE, PostgreSQLParserXMLPI, PostgreSQLParserXMLROOT, PostgreSQLParserXMLSERIALIZE, PostgreSQLParserCALL, PostgreSQLParserCURRENT_P, PostgreSQLParserATTACH, PostgreSQLParserDETACH, PostgreSQLParserEXPRESSION, PostgreSQLParserGENERATED, PostgreSQLParserLOGGED, PostgreSQLParserSTORED, PostgreSQLParserINCLUDE, PostgreSQLParserROUTINE, PostgreSQLParserTRANSFORM, PostgreSQLParserIMPORT_P, PostgreSQLParserPOLICY, PostgreSQLParserMETHOD, PostgreSQLParserREFERENCING, PostgreSQLParserNEW, PostgreSQLParserOLD, PostgreSQLParserVALUE_P, PostgreSQLParserSUBSCRIPTION, PostgreSQLParserPUBLICATION, PostgreSQLParserOUT_P, PostgreSQLParserROUTINES, PostgreSQLParserSCHEMAS, PostgreSQLParserPROCEDURES, PostgreSQLParserINPUT_P, PostgreSQLParserSUPPORT, PostgreSQLParserPARALLEL, PostgreSQLParserSQL_P, PostgreSQLParserDEPENDS, PostgreSQLParserOVERRIDING, PostgreSQLParserCONFLICT, PostgreSQLParserSKIP_P, PostgreSQLParserLOCKED, PostgreSQLParserTIES, PostgreSQLParserROLLUP, PostgreSQLParserCUBE, PostgreSQLParserGROUPING, PostgreSQLParserSETS, PostgreSQLParserTABLESAMPLE, PostgreSQLParserORDINALITY, PostgreSQLParserXMLTABLE, PostgreSQLParserCOLUMNS, PostgreSQLParserXMLNAMESPACES, PostgreSQLParserROWTYPE, PostgreSQLParserNORMALIZED, PostgreSQLParserWITHIN, PostgreSQLParserFILTER, PostgreSQLParserGROUPS, PostgreSQLParserOTHERS, PostgreSQLParserNFC, PostgreSQLParserNFD, PostgreSQLParserNFKC, PostgreSQLParserNFKD, PostgreSQLParserUESCAPE, PostgreSQLParserVIEWS, PostgreSQLParserNORMALIZE, PostgreSQLParserDUMP, PostgreSQLParserPRINT_STRICT_PARAMS, PostgreSQLParserVARIABLE_CONFLICT, PostgreSQLParserERROR, PostgreSQLParserUSE_VARIABLE, PostgreSQLParserUSE_COLUMN, PostgreSQLParserALIAS, PostgreSQLParserCONSTANT, PostgreSQLParserPERFORM, PostgreSQLParserGET, PostgreSQLParserDIAGNOSTICS, PostgreSQLParserSTACKED, PostgreSQLParserELSIF, PostgreSQLParserREVERSE, PostgreSQLParserSLICE, PostgreSQLParserEXIT, PostgreSQLParserRETURN, PostgreSQLParserQUERY, PostgreSQLParserRAISE, PostgreSQLParserSQLSTATE, PostgreSQLParserDEBUG, PostgreSQLParserLOG, PostgreSQLParserINFO, PostgreSQLParserNOTICE, PostgreSQLParserWARNING, PostgreSQLParserEXCEPTION, PostgreSQLParserASSERT, PostgreSQLParserOPEN, PostgreSQLParserABS, PostgreSQLParserCBRT, PostgreSQLParserCEIL, PostgreSQLParserCEILING, PostgreSQLParserDEGREES, PostgreSQLParserDIV, PostgreSQLParserEXP, PostgreSQLParserFACTORIAL, PostgreSQLParserFLOOR, PostgreSQLParserGCD, PostgreSQLParserLCM, PostgreSQLParserLN, PostgreSQLParserLOG10, PostgreSQLParserMIN_SCALE, PostgreSQLParserMOD, PostgreSQLParserPI, PostgreSQLParserPOWER, PostgreSQLParserRADIANS, PostgreSQLParserROUND, PostgreSQLParserSCALE, PostgreSQLParserSIGN, PostgreSQLParserSQRT, PostgreSQLParserTRIM_SCALE, PostgreSQLParserTRUNC, PostgreSQLParserWIDTH_BUCKET, PostgreSQLParserRANDOM, PostgreSQLParserSETSEED, PostgreSQLParserACOS, PostgreSQLParserACOSD, PostgreSQLParserASIN, PostgreSQLParserASIND, PostgreSQLParserATAN, PostgreSQLParserATAND, PostgreSQLParserATAN2, PostgreSQLParserATAN2D, PostgreSQLParserCOS, PostgreSQLParserCOSD, PostgreSQLParserCOT, PostgreSQLParserCOTD, PostgreSQLParserSIN, PostgreSQLParserSIND, PostgreSQLParserTAN, PostgreSQLParserTAND, PostgreSQLParserSINH, PostgreSQLParserCOSH, PostgreSQLParserTANH, PostgreSQLParserASINH, PostgreSQLParserACOSH, PostgreSQLParserATANH, PostgreSQLParserBIT_LENGTH, PostgreSQLParserCHAR_LENGTH, PostgreSQLParserCHARACTER_LENGTH, PostgreSQLParserLOWER, PostgreSQLParserOCTET_LENGTH, PostgreSQLParserUPPER, PostgreSQLParserASCII, PostgreSQLParserBTRIM, PostgreSQLParserCHR, PostgreSQLParserCONCAT, PostgreSQLParserCONCAT_WS, PostgreSQLParserFORMAT, PostgreSQLParserINITCAP, PostgreSQLParserLENGTH, PostgreSQLParserLPAD, PostgreSQLParserLTRIM, PostgreSQLParserMD5, PostgreSQLParserPARSE_IDENT, PostgreSQLParserPG_CLIENT_ENCODING, PostgreSQLParserQUOTE_IDENT, PostgreSQLParserQUOTE_LITERAL, PostgreSQLParserQUOTE_NULLABLE, PostgreSQLParserREGEXP_COUNT, PostgreSQLParserREGEXP_INSTR, PostgreSQLParserREGEXP_LIKE, PostgreSQLParserREGEXP_MATCH, PostgreSQLParserREGEXP_MATCHES, PostgreSQLParserREGEXP_REPLACE, PostgreSQLParserREGEXP_SPLIT_TO_ARRAY, PostgreSQLParserREGEXP_SPLIT_TO_TABLE, PostgreSQLParserREGEXP_SUBSTR, PostgreSQLParserREPEAT, PostgreSQLParserRPAD, PostgreSQLParserRTRIM, PostgreSQLParserSPLIT_PART, PostgreSQLParserSTARTS_WITH, PostgreSQLParserSTRING_TO_ARRAY, PostgreSQLParserSTRING_TO_TABLE, PostgreSQLParserSTRPOS, PostgreSQLParserSUBSTR, PostgreSQLParserTO_ASCII, PostgreSQLParserTO_HEX, PostgreSQLParserTRANSLATE, PostgreSQLParserUNISTR, PostgreSQLParserAGE, PostgreSQLParserCLOCK_TIMESTAMP, PostgreSQLParserDATE_BIN, PostgreSQLParserDATE_PART, PostgreSQLParserDATE_TRUNC, PostgreSQLParserISFINITE, PostgreSQLParserJUSTIFY_DAYS, PostgreSQLParserJUSTIFY_HOURS, PostgreSQLParserJUSTIFY_INTERVAL, PostgreSQLParserMAKE_DATE, PostgreSQLParserMAKE_INTERVAL, PostgreSQLParserMAKE_TIME, PostgreSQLParserMAKE_TIMESTAMP, PostgreSQLParserMAKE_TIMESTAMPTZ, PostgreSQLParserNOW, PostgreSQLParserSTATEMENT_TIMESTAMP, PostgreSQLParserTIMEOFDAY, PostgreSQLParserTRANSACTION_TIMESTAMP, PostgreSQLParserTO_TIMESTAMP, PostgreSQLParserTO_CHAR, PostgreSQLParserTO_DATE, PostgreSQLParserTO_NUMBER, PostgreSQLParserIdentifier, PostgreSQLParserQuotedIdentifier, PostgreSQLParserUnicodeQuotedIdentifier, PostgreSQLParserStringConstant, PostgreSQLParserUnicodeEscapeStringConstant, PostgreSQLParserBeginDollarStringConstant, PostgreSQLParserBinaryStringConstant, PostgreSQLParserHexadecimalStringConstant, PostgreSQLParserIntegral, PostgreSQLParserNumeric, PostgreSQLParserPLSQLVARIABLENAME, PostgreSQLParserPLSQLIDENTIFIER, PostgreSQLParserEscapeStringConstant:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(10164)
			p.Expr_list()
		}

	default:
		p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IStmt_assignContext is an interface to support dynamic dispatch.
type IStmt_assignContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Assign_var() IAssign_varContext
	Assign_operator() IAssign_operatorContext
	Sql_expression() ISql_expressionContext
	SEMI() antlr.TerminalNode

	// IsStmt_assignContext differentiates from other interfaces.
	IsStmt_assignContext()
}

type Stmt_assignContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyStmt_assignContext() *Stmt_assignContext {
	var p = new(Stmt_assignContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_stmt_assign
	return p
}

func InitEmptyStmt_assignContext(p *Stmt_assignContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_stmt_assign
}

func (*Stmt_assignContext) IsStmt_assignContext() {}

func NewStmt_assignContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Stmt_assignContext {
	var p = new(Stmt_assignContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_stmt_assign

	return p
}

func (s *Stmt_assignContext) GetParser() antlr.Parser { return s.parser }

func (s *Stmt_assignContext) Assign_var() IAssign_varContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IAssign_varContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IAssign_varContext)
}

func (s *Stmt_assignContext) Assign_operator() IAssign_operatorContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IAssign_operatorContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IAssign_operatorContext)
}

func (s *Stmt_assignContext) Sql_expression() ISql_expressionContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ISql_expressionContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ISql_expressionContext)
}

func (s *Stmt_assignContext) SEMI() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserSEMI, 0)
}

func (s *Stmt_assignContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Stmt_assignContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Stmt_assignContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterStmt_assign(s)
	}
}

func (s *Stmt_assignContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitStmt_assign(s)
	}
}

func (s *Stmt_assignContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitStmt_assign(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Stmt_assign() (localctx IStmt_assignContext) {
	localctx = NewStmt_assignContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1462, PostgreSQLParserRULE_stmt_assign)
	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(10167)
		p.Assign_var()
	}
	{
		p.SetState(10168)
		p.Assign_operator()
	}
	{
		p.SetState(10169)
		p.Sql_expression()
	}
	{
		p.SetState(10170)
		p.Match(PostgreSQLParserSEMI)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IStmt_getdiagContext is an interface to support dynamic dispatch.
type IStmt_getdiagContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	GET() antlr.TerminalNode
	Getdiag_area_opt() IGetdiag_area_optContext
	DIAGNOSTICS() antlr.TerminalNode
	Getdiag_list() IGetdiag_listContext
	SEMI() antlr.TerminalNode

	// IsStmt_getdiagContext differentiates from other interfaces.
	IsStmt_getdiagContext()
}

type Stmt_getdiagContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyStmt_getdiagContext() *Stmt_getdiagContext {
	var p = new(Stmt_getdiagContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_stmt_getdiag
	return p
}

func InitEmptyStmt_getdiagContext(p *Stmt_getdiagContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_stmt_getdiag
}

func (*Stmt_getdiagContext) IsStmt_getdiagContext() {}

func NewStmt_getdiagContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Stmt_getdiagContext {
	var p = new(Stmt_getdiagContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_stmt_getdiag

	return p
}

func (s *Stmt_getdiagContext) GetParser() antlr.Parser { return s.parser }

func (s *Stmt_getdiagContext) GET() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserGET, 0)
}

func (s *Stmt_getdiagContext) Getdiag_area_opt() IGetdiag_area_optContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IGetdiag_area_optContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IGetdiag_area_optContext)
}

func (s *Stmt_getdiagContext) DIAGNOSTICS() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserDIAGNOSTICS, 0)
}

func (s *Stmt_getdiagContext) Getdiag_list() IGetdiag_listContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IGetdiag_listContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IGetdiag_listContext)
}

func (s *Stmt_getdiagContext) SEMI() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserSEMI, 0)
}

func (s *Stmt_getdiagContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Stmt_getdiagContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Stmt_getdiagContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterStmt_getdiag(s)
	}
}

func (s *Stmt_getdiagContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitStmt_getdiag(s)
	}
}

func (s *Stmt_getdiagContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitStmt_getdiag(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Stmt_getdiag() (localctx IStmt_getdiagContext) {
	localctx = NewStmt_getdiagContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1464, PostgreSQLParserRULE_stmt_getdiag)
	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(10172)
		p.Match(PostgreSQLParserGET)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(10173)
		p.Getdiag_area_opt()
	}
	{
		p.SetState(10174)
		p.Match(PostgreSQLParserDIAGNOSTICS)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(10175)
		p.Getdiag_list()
	}
	{
		p.SetState(10176)
		p.Match(PostgreSQLParserSEMI)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IGetdiag_area_optContext is an interface to support dynamic dispatch.
type IGetdiag_area_optContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	CURRENT_P() antlr.TerminalNode
	STACKED() antlr.TerminalNode

	// IsGetdiag_area_optContext differentiates from other interfaces.
	IsGetdiag_area_optContext()
}

type Getdiag_area_optContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyGetdiag_area_optContext() *Getdiag_area_optContext {
	var p = new(Getdiag_area_optContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_getdiag_area_opt
	return p
}

func InitEmptyGetdiag_area_optContext(p *Getdiag_area_optContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_getdiag_area_opt
}

func (*Getdiag_area_optContext) IsGetdiag_area_optContext() {}

func NewGetdiag_area_optContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Getdiag_area_optContext {
	var p = new(Getdiag_area_optContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_getdiag_area_opt

	return p
}

func (s *Getdiag_area_optContext) GetParser() antlr.Parser { return s.parser }

func (s *Getdiag_area_optContext) CURRENT_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCURRENT_P, 0)
}

func (s *Getdiag_area_optContext) STACKED() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserSTACKED, 0)
}

func (s *Getdiag_area_optContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Getdiag_area_optContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Getdiag_area_optContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterGetdiag_area_opt(s)
	}
}

func (s *Getdiag_area_optContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitGetdiag_area_opt(s)
	}
}

func (s *Getdiag_area_optContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitGetdiag_area_opt(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Getdiag_area_opt() (localctx IGetdiag_area_optContext) {
	localctx = NewGetdiag_area_optContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1466, PostgreSQLParserRULE_getdiag_area_opt)
	p.SetState(10181)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetTokenStream().LA(1) {
	case PostgreSQLParserDIAGNOSTICS:
		p.EnterOuterAlt(localctx, 1)

	case PostgreSQLParserCURRENT_P:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(10179)
			p.Match(PostgreSQLParserCURRENT_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case PostgreSQLParserSTACKED:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(10180)
			p.Match(PostgreSQLParserSTACKED)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	default:
		p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IGetdiag_listContext is an interface to support dynamic dispatch.
type IGetdiag_listContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	AllGetdiag_list_item() []IGetdiag_list_itemContext
	Getdiag_list_item(i int) IGetdiag_list_itemContext
	AllCOMMA() []antlr.TerminalNode
	COMMA(i int) antlr.TerminalNode

	// IsGetdiag_listContext differentiates from other interfaces.
	IsGetdiag_listContext()
}

type Getdiag_listContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyGetdiag_listContext() *Getdiag_listContext {
	var p = new(Getdiag_listContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_getdiag_list
	return p
}

func InitEmptyGetdiag_listContext(p *Getdiag_listContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_getdiag_list
}

func (*Getdiag_listContext) IsGetdiag_listContext() {}

func NewGetdiag_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Getdiag_listContext {
	var p = new(Getdiag_listContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_getdiag_list

	return p
}

func (s *Getdiag_listContext) GetParser() antlr.Parser { return s.parser }

func (s *Getdiag_listContext) AllGetdiag_list_item() []IGetdiag_list_itemContext {
	children := s.GetChildren()
	len := 0
	for _, ctx := range children {
		if _, ok := ctx.(IGetdiag_list_itemContext); ok {
			len++
		}
	}

	tst := make([]IGetdiag_list_itemContext, len)
	i := 0
	for _, ctx := range children {
		if t, ok := ctx.(IGetdiag_list_itemContext); ok {
			tst[i] = t.(IGetdiag_list_itemContext)
			i++
		}
	}

	return tst
}

func (s *Getdiag_listContext) Getdiag_list_item(i int) IGetdiag_list_itemContext {
	var t antlr.RuleContext
	j := 0
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IGetdiag_list_itemContext); ok {
			if j == i {
				t = ctx.(antlr.RuleContext)
				break
			}
			j++
		}
	}

	if t == nil {
		return nil
	}

	return t.(IGetdiag_list_itemContext)
}

func (s *Getdiag_listContext) AllCOMMA() []antlr.TerminalNode {
	return s.GetTokens(PostgreSQLParserCOMMA)
}

func (s *Getdiag_listContext) COMMA(i int) antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCOMMA, i)
}

func (s *Getdiag_listContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Getdiag_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Getdiag_listContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterGetdiag_list(s)
	}
}

func (s *Getdiag_listContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitGetdiag_list(s)
	}
}

func (s *Getdiag_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitGetdiag_list(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Getdiag_list() (localctx IGetdiag_listContext) {
	localctx = NewGetdiag_listContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1468, PostgreSQLParserRULE_getdiag_list)
	var _la int

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(10183)
		p.Getdiag_list_item()
	}
	p.SetState(10188)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}
	_la = p.GetTokenStream().LA(1)

	for _la == PostgreSQLParserCOMMA {
		{
			p.SetState(10184)
			p.Match(PostgreSQLParserCOMMA)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(10185)
			p.Getdiag_list_item()
		}

		p.SetState(10190)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}
		_la = p.GetTokenStream().LA(1)
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IGetdiag_list_itemContext is an interface to support dynamic dispatch.
type IGetdiag_list_itemContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Getdiag_target() IGetdiag_targetContext
	Assign_operator() IAssign_operatorContext
	Getdiag_item() IGetdiag_itemContext

	// IsGetdiag_list_itemContext differentiates from other interfaces.
	IsGetdiag_list_itemContext()
}

type Getdiag_list_itemContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyGetdiag_list_itemContext() *Getdiag_list_itemContext {
	var p = new(Getdiag_list_itemContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_getdiag_list_item
	return p
}

func InitEmptyGetdiag_list_itemContext(p *Getdiag_list_itemContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_getdiag_list_item
}

func (*Getdiag_list_itemContext) IsGetdiag_list_itemContext() {}

func NewGetdiag_list_itemContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Getdiag_list_itemContext {
	var p = new(Getdiag_list_itemContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_getdiag_list_item

	return p
}

func (s *Getdiag_list_itemContext) GetParser() antlr.Parser { return s.parser }

func (s *Getdiag_list_itemContext) Getdiag_target() IGetdiag_targetContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IGetdiag_targetContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IGetdiag_targetContext)
}

func (s *Getdiag_list_itemContext) Assign_operator() IAssign_operatorContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IAssign_operatorContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IAssign_operatorContext)
}

func (s *Getdiag_list_itemContext) Getdiag_item() IGetdiag_itemContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IGetdiag_itemContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IGetdiag_itemContext)
}

func (s *Getdiag_list_itemContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Getdiag_list_itemContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Getdiag_list_itemContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterGetdiag_list_item(s)
	}
}

func (s *Getdiag_list_itemContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitGetdiag_list_item(s)
	}
}

func (s *Getdiag_list_itemContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitGetdiag_list_item(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Getdiag_list_item() (localctx IGetdiag_list_itemContext) {
	localctx = NewGetdiag_list_itemContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1470, PostgreSQLParserRULE_getdiag_list_item)
	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(10191)
		p.Getdiag_target()
	}
	{
		p.SetState(10192)
		p.Assign_operator()
	}
	{
		p.SetState(10193)
		p.Getdiag_item()
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IGetdiag_itemContext is an interface to support dynamic dispatch.
type IGetdiag_itemContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Colid() IColidContext

	// IsGetdiag_itemContext differentiates from other interfaces.
	IsGetdiag_itemContext()
}

type Getdiag_itemContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyGetdiag_itemContext() *Getdiag_itemContext {
	var p = new(Getdiag_itemContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_getdiag_item
	return p
}

func InitEmptyGetdiag_itemContext(p *Getdiag_itemContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_getdiag_item
}

func (*Getdiag_itemContext) IsGetdiag_itemContext() {}

func NewGetdiag_itemContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Getdiag_itemContext {
	var p = new(Getdiag_itemContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_getdiag_item

	return p
}

func (s *Getdiag_itemContext) GetParser() antlr.Parser { return s.parser }

func (s *Getdiag_itemContext) Colid() IColidContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IColidContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IColidContext)
}

func (s *Getdiag_itemContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Getdiag_itemContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Getdiag_itemContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterGetdiag_item(s)
	}
}

func (s *Getdiag_itemContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitGetdiag_item(s)
	}
}

func (s *Getdiag_itemContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitGetdiag_item(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Getdiag_item() (localctx IGetdiag_itemContext) {
	localctx = NewGetdiag_itemContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1472, PostgreSQLParserRULE_getdiag_item)
	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(10195)
		p.Colid()
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IGetdiag_targetContext is an interface to support dynamic dispatch.
type IGetdiag_targetContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Assign_var() IAssign_varContext

	// IsGetdiag_targetContext differentiates from other interfaces.
	IsGetdiag_targetContext()
}

type Getdiag_targetContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyGetdiag_targetContext() *Getdiag_targetContext {
	var p = new(Getdiag_targetContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_getdiag_target
	return p
}

func InitEmptyGetdiag_targetContext(p *Getdiag_targetContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_getdiag_target
}

func (*Getdiag_targetContext) IsGetdiag_targetContext() {}

func NewGetdiag_targetContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Getdiag_targetContext {
	var p = new(Getdiag_targetContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_getdiag_target

	return p
}

func (s *Getdiag_targetContext) GetParser() antlr.Parser { return s.parser }

func (s *Getdiag_targetContext) Assign_var() IAssign_varContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IAssign_varContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IAssign_varContext)
}

func (s *Getdiag_targetContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Getdiag_targetContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Getdiag_targetContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterGetdiag_target(s)
	}
}

func (s *Getdiag_targetContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitGetdiag_target(s)
	}
}

func (s *Getdiag_targetContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitGetdiag_target(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Getdiag_target() (localctx IGetdiag_targetContext) {
	localctx = NewGetdiag_targetContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1474, PostgreSQLParserRULE_getdiag_target)
	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(10197)
		p.Assign_var()
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IAssign_varContext is an interface to support dynamic dispatch.
type IAssign_varContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Any_name() IAny_nameContext
	PARAM() antlr.TerminalNode
	AllOPEN_BRACKET() []antlr.TerminalNode
	OPEN_BRACKET(i int) antlr.TerminalNode
	AllExpr_until_rightbracket() []IExpr_until_rightbracketContext
	Expr_until_rightbracket(i int) IExpr_until_rightbracketContext
	AllCLOSE_BRACKET() []antlr.TerminalNode
	CLOSE_BRACKET(i int) antlr.TerminalNode

	// IsAssign_varContext differentiates from other interfaces.
	IsAssign_varContext()
}

type Assign_varContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyAssign_varContext() *Assign_varContext {
	var p = new(Assign_varContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_assign_var
	return p
}

func InitEmptyAssign_varContext(p *Assign_varContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_assign_var
}

func (*Assign_varContext) IsAssign_varContext() {}

func NewAssign_varContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Assign_varContext {
	var p = new(Assign_varContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_assign_var

	return p
}

func (s *Assign_varContext) GetParser() antlr.Parser { return s.parser }

func (s *Assign_varContext) Any_name() IAny_nameContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IAny_nameContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IAny_nameContext)
}

func (s *Assign_varContext) PARAM() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserPARAM, 0)
}

func (s *Assign_varContext) AllOPEN_BRACKET() []antlr.TerminalNode {
	return s.GetTokens(PostgreSQLParserOPEN_BRACKET)
}

func (s *Assign_varContext) OPEN_BRACKET(i int) antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserOPEN_BRACKET, i)
}

func (s *Assign_varContext) AllExpr_until_rightbracket() []IExpr_until_rightbracketContext {
	children := s.GetChildren()
	len := 0
	for _, ctx := range children {
		if _, ok := ctx.(IExpr_until_rightbracketContext); ok {
			len++
		}
	}

	tst := make([]IExpr_until_rightbracketContext, len)
	i := 0
	for _, ctx := range children {
		if t, ok := ctx.(IExpr_until_rightbracketContext); ok {
			tst[i] = t.(IExpr_until_rightbracketContext)
			i++
		}
	}

	return tst
}

func (s *Assign_varContext) Expr_until_rightbracket(i int) IExpr_until_rightbracketContext {
	var t antlr.RuleContext
	j := 0
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IExpr_until_rightbracketContext); ok {
			if j == i {
				t = ctx.(antlr.RuleContext)
				break
			}
			j++
		}
	}

	if t == nil {
		return nil
	}

	return t.(IExpr_until_rightbracketContext)
}

func (s *Assign_varContext) AllCLOSE_BRACKET() []antlr.TerminalNode {
	return s.GetTokens(PostgreSQLParserCLOSE_BRACKET)
}

func (s *Assign_varContext) CLOSE_BRACKET(i int) antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCLOSE_BRACKET, i)
}

func (s *Assign_varContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Assign_varContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Assign_varContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterAssign_var(s)
	}
}

func (s *Assign_varContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitAssign_var(s)
	}
}

func (s *Assign_varContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitAssign_var(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Assign_var() (localctx IAssign_varContext) {
	localctx = NewAssign_varContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1476, PostgreSQLParserRULE_assign_var)
	var _la int

	p.EnterOuterAlt(localctx, 1)
	p.SetState(10201)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetTokenStream().LA(1) {
	case PostgreSQLParserAND, PostgreSQLParserARRAY, PostgreSQLParserCOLLATE, PostgreSQLParserCOLUMN, PostgreSQLParserCONSTRAINT, PostgreSQLParserDEFAULT, PostgreSQLParserDO, PostgreSQLParserFETCH, PostgreSQLParserTABLE, PostgreSQLParserIS, PostgreSQLParserLEFT, PostgreSQLParserOUTER_P, PostgreSQLParserOVER, PostgreSQLParserRIGHT, PostgreSQLParserABORT_P, PostgreSQLParserABSOLUTE_P, PostgreSQLParserACCESS, PostgreSQLParserACTION, PostgreSQLParserADD_P, PostgreSQLParserADMIN, PostgreSQLParserAFTER, PostgreSQLParserAGGREGATE, PostgreSQLParserALSO, PostgreSQLParserALTER, PostgreSQLParserALWAYS, PostgreSQLParserASSERTION, PostgreSQLParserASSIGNMENT, PostgreSQLParserAT, PostgreSQLParserATTRIBUTE, PostgreSQLParserBACKWARD, PostgreSQLParserBEFORE, PostgreSQLParserBEGIN_P, PostgreSQLParserBY, PostgreSQLParserCACHE, PostgreSQLParserCALLED, PostgreSQLParserCASCADE, PostgreSQLParserCASCADED, PostgreSQLParserCATALOG, PostgreSQLParserCHAIN, PostgreSQLParserCHARACTERISTICS, PostgreSQLParserCHECKPOINT, PostgreSQLParserCLASS, PostgreSQLParserCLOSE, PostgreSQLParserCLUSTER, PostgreSQLParserCOMMENT, PostgreSQLParserCOMMENTS, PostgreSQLParserCOMMIT, PostgreSQLParserCOMMITTED, PostgreSQLParserCONFIGURATION, PostgreSQLParserCONNECTION, PostgreSQLParserCONSTRAINTS, PostgreSQLParserCONTENT_P, PostgreSQLParserCONTINUE_P, PostgreSQLParserCONVERSION_P, PostgreSQLParserCOPY, PostgreSQLParserCOST, PostgreSQLParserCSV, PostgreSQLParserCURSOR, PostgreSQLParserCYCLE, PostgreSQLParserDATA_P, PostgreSQLParserDATABASE, PostgreSQLParserDAY_P, PostgreSQLParserDEALLOCATE, PostgreSQLParserDECLARE, PostgreSQLParserDEFAULTS, PostgreSQLParserDEFERRED, PostgreSQLParserDEFINER, PostgreSQLParserDELETE_P, PostgreSQLParserDELIMITER, PostgreSQLParserDELIMITERS, PostgreSQLParserDICTIONARY, PostgreSQLParserDISABLE_P, PostgreSQLParserDISCARD, PostgreSQLParserDOCUMENT_P, PostgreSQLParserDOMAIN_P, PostgreSQLParserDOUBLE_P, PostgreSQLParserDROP, PostgreSQLParserEACH, PostgreSQLParserENABLE_P, PostgreSQLParserENCODING, PostgreSQLParserENCRYPTED, PostgreSQLParserENUM_P, PostgreSQLParserESCAPE, PostgreSQLParserEVENT, PostgreSQLParserEXCLUDE, PostgreSQLParserEXCLUDING, PostgreSQLParserEXCLUSIVE, PostgreSQLParserEXECUTE, PostgreSQLParserEXPLAIN, PostgreSQLParserEXTENSION, PostgreSQLParserEXTERNAL, PostgreSQLParserFAMILY, PostgreSQLParserFIRST_P, PostgreSQLParserFOLLOWING, PostgreSQLParserFORCE, PostgreSQLParserFORWARD, PostgreSQLParserFUNCTION, PostgreSQLParserFUNCTIONS, PostgreSQLParserGLOBAL, PostgreSQLParserGRANTED, PostgreSQLParserHANDLER, PostgreSQLParserHEADER_P, PostgreSQLParserHOLD, PostgreSQLParserHOUR_P, PostgreSQLParserIDENTITY_P, PostgreSQLParserIF_P, PostgreSQLParserIMMEDIATE, PostgreSQLParserIMMUTABLE, PostgreSQLParserIMPLICIT_P, PostgreSQLParserINCLUDING, PostgreSQLParserINCREMENT, PostgreSQLParserINDEX, PostgreSQLParserINDEXES, PostgreSQLParserINHERIT, PostgreSQLParserINHERITS, PostgreSQLParserINLINE_P, PostgreSQLParserINSENSITIVE, PostgreSQLParserINSERT, PostgreSQLParserINSTEAD, PostgreSQLParserINVOKER, PostgreSQLParserISOLATION, PostgreSQLParserKEY, PostgreSQLParserLABEL, PostgreSQLParserLANGUAGE, PostgreSQLParserLARGE_P, PostgreSQLParserLAST_P, PostgreSQLParserLEAKPROOF, PostgreSQLParserLEVEL, PostgreSQLParserLISTEN, PostgreSQLParserLOAD, PostgreSQLParserLOCAL, PostgreSQLParserLOCATION, PostgreSQLParserLOCK_P, PostgreSQLParserMAPPING, PostgreSQLParserMATCH, PostgreSQLParserMATERIALIZED, PostgreSQLParserMAXVALUE, PostgreSQLParserMINUTE_P, PostgreSQLParserMINVALUE, PostgreSQLParserMODE, PostgreSQLParserMONTH_P, PostgreSQLParserMOVE, PostgreSQLParserNAME_P, PostgreSQLParserNAMES, PostgreSQLParserNEXT, PostgreSQLParserNO, PostgreSQLParserNOTHING, PostgreSQLParserNOTIFY, PostgreSQLParserNOWAIT, PostgreSQLParserNULLS_P, PostgreSQLParserOBJECT_P, PostgreSQLParserOF, PostgreSQLParserOFF, PostgreSQLParserOIDS, PostgreSQLParserOPERATOR, PostgreSQLParserOPTION, PostgreSQLParserOPTIONS, PostgreSQLParserOWNED, PostgreSQLParserOWNER, PostgreSQLParserPARSER, PostgreSQLParserPARTIAL, PostgreSQLParserPARTITION, PostgreSQLParserPASSING, PostgreSQLParserPASSWORD, PostgreSQLParserPLANS, PostgreSQLParserPRECEDING, PostgreSQLParserPREPARE, PostgreSQLParserPREPARED, PostgreSQLParserPRESERVE, PostgreSQLParserPRIOR, PostgreSQLParserPRIVILEGES, PostgreSQLParserPROCEDURAL, PostgreSQLParserPROCEDURE, PostgreSQLParserPROGRAM, PostgreSQLParserQUOTE, PostgreSQLParserRANGE, PostgreSQLParserREAD, PostgreSQLParserREASSIGN, PostgreSQLParserRECHECK, PostgreSQLParserRECURSIVE, PostgreSQLParserREF, PostgreSQLParserREFRESH, PostgreSQLParserREINDEX, PostgreSQLParserRELATIVE_P, PostgreSQLParserRELEASE, PostgreSQLParserRENAME, PostgreSQLParserREPEATABLE, PostgreSQLParserREPLACE, PostgreSQLParserREPLICA, PostgreSQLParserRESET, PostgreSQLParserRESTART, PostgreSQLParserRESTRICT, PostgreSQLParserRETURNS, PostgreSQLParserREVOKE, PostgreSQLParserROLE, PostgreSQLParserROLLBACK, PostgreSQLParserROWS, PostgreSQLParserRULE, PostgreSQLParserSAVEPOINT, PostgreSQLParserSCHEMA, PostgreSQLParserSCROLL, PostgreSQLParserSEARCH, PostgreSQLParserSECOND_P, PostgreSQLParserSECURITY, PostgreSQLParserSEQUENCE, PostgreSQLParserSEQUENCES, PostgreSQLParserSERIALIZABLE, PostgreSQLParserSERVER, PostgreSQLParserSESSION, PostgreSQLParserSET, PostgreSQLParserSHARE, PostgreSQLParserSHOW, PostgreSQLParserSIMPLE, PostgreSQLParserSNAPSHOT, PostgreSQLParserSTABLE, PostgreSQLParserSTANDALONE_P, PostgreSQLParserSTART, PostgreSQLParserSTATEMENT, PostgreSQLParserSTATISTICS, PostgreSQLParserSTDIN, PostgreSQLParserSTDOUT, PostgreSQLParserSTORAGE, PostgreSQLParserSTRICT_P, PostgreSQLParserSTRIP_P, PostgreSQLParserSYSID, PostgreSQLParserSYSTEM_P, PostgreSQLParserTABLES, PostgreSQLParserTABLESPACE, PostgreSQLParserTEMP, PostgreSQLParserTEMPLATE, PostgreSQLParserTEMPORARY, PostgreSQLParserTEXT_P, PostgreSQLParserTRANSACTION, PostgreSQLParserTRIGGER, PostgreSQLParserTRUNCATE, PostgreSQLParserTRUSTED, PostgreSQLParserTYPE_P, PostgreSQLParserTYPES_P, PostgreSQLParserUNBOUNDED, PostgreSQLParserUNCOMMITTED, PostgreSQLParserUNENCRYPTED, PostgreSQLParserUNKNOWN, PostgreSQLParserUNLISTEN, PostgreSQLParserUNLOGGED, PostgreSQLParserUNTIL, PostgreSQLParserUPDATE, PostgreSQLParserVACUUM, PostgreSQLParserVALID, PostgreSQLParserVALIDATE, PostgreSQLParserVALIDATOR, PostgreSQLParserVARYING, PostgreSQLParserVERSION_P, PostgreSQLParserVIEW, PostgreSQLParserVOLATILE, PostgreSQLParserWHITESPACE_P, PostgreSQLParserWITHOUT, PostgreSQLParserWORK, PostgreSQLParserWRAPPER, PostgreSQLParserWRITE, PostgreSQLParserXML_P, PostgreSQLParserYEAR_P, PostgreSQLParserYES_P, PostgreSQLParserZONE, PostgreSQLParserBETWEEN, PostgreSQLParserBIGINT, PostgreSQLParserBIT, PostgreSQLParserBOOLEAN_P, PostgreSQLParserCHAR_P, PostgreSQLParserCHARACTER, PostgreSQLParserCOALESCE, PostgreSQLParserDEC, PostgreSQLParserDECIMAL_P, PostgreSQLParserEXISTS, PostgreSQLParserEXTRACT, PostgreSQLParserFLOAT_P, PostgreSQLParserGREATEST, PostgreSQLParserINOUT, PostgreSQLParserINT_P, PostgreSQLParserINTEGER, PostgreSQLParserINTERVAL, PostgreSQLParserLEAST, PostgreSQLParserNATIONAL, PostgreSQLParserNCHAR, PostgreSQLParserNONE, PostgreSQLParserNULLIF, PostgreSQLParserNUMERIC, PostgreSQLParserOVERLAY, PostgreSQLParserPOSITION, PostgreSQLParserPRECISION, PostgreSQLParserREAL, PostgreSQLParserROW, PostgreSQLParserSETOF, PostgreSQLParserSMALLINT, PostgreSQLParserSUBSTRING, PostgreSQLParserTIME, PostgreSQLParserTIMESTAMP, PostgreSQLParserTREAT, PostgreSQLParserTRIM, PostgreSQLParserVALUES, PostgreSQLParserVARCHAR, PostgreSQLParserXMLATTRIBUTES, PostgreSQLParserXMLCOMMENT, PostgreSQLParserXMLAGG, PostgreSQLParserXML_IS_WELL_FORMED, PostgreSQLParserXML_IS_WELL_FORMED_DOCUMENT, PostgreSQLParserXML_IS_WELL_FORMED_CONTENT, PostgreSQLParserXPATH, PostgreSQLParserXPATH_EXISTS, PostgreSQLParserXMLCONCAT, PostgreSQLParserXMLELEMENT, PostgreSQLParserXMLEXISTS, PostgreSQLParserXMLFOREST, PostgreSQLParserXMLPARSE, PostgreSQLParserXMLPI, PostgreSQLParserXMLROOT, PostgreSQLParserXMLSERIALIZE, PostgreSQLParserCALL, PostgreSQLParserCURRENT_P, PostgreSQLParserATTACH, PostgreSQLParserDETACH, PostgreSQLParserEXPRESSION, PostgreSQLParserGENERATED, PostgreSQLParserLOGGED, PostgreSQLParserSTORED, PostgreSQLParserINCLUDE, PostgreSQLParserROUTINE, PostgreSQLParserTRANSFORM, PostgreSQLParserIMPORT_P, PostgreSQLParserPOLICY, PostgreSQLParserMETHOD, PostgreSQLParserREFERENCING, PostgreSQLParserNEW, PostgreSQLParserOLD, PostgreSQLParserVALUE_P, PostgreSQLParserSUBSCRIPTION, PostgreSQLParserPUBLICATION, PostgreSQLParserOUT_P, PostgreSQLParserROUTINES, PostgreSQLParserSCHEMAS, PostgreSQLParserPROCEDURES, PostgreSQLParserINPUT_P, PostgreSQLParserSUPPORT, PostgreSQLParserPARALLEL, PostgreSQLParserSQL_P, PostgreSQLParserDEPENDS, PostgreSQLParserOVERRIDING, PostgreSQLParserCONFLICT, PostgreSQLParserSKIP_P, PostgreSQLParserLOCKED, PostgreSQLParserTIES, PostgreSQLParserROLLUP, PostgreSQLParserCUBE, PostgreSQLParserGROUPING, PostgreSQLParserSETS, PostgreSQLParserORDINALITY, PostgreSQLParserXMLTABLE, PostgreSQLParserCOLUMNS, PostgreSQLParserXMLNAMESPACES, PostgreSQLParserROWTYPE, PostgreSQLParserNORMALIZED, PostgreSQLParserWITHIN, PostgreSQLParserFILTER, PostgreSQLParserGROUPS, PostgreSQLParserOTHERS, PostgreSQLParserNFC, PostgreSQLParserNFD, PostgreSQLParserNFKC, PostgreSQLParserNFKD, PostgreSQLParserUESCAPE, PostgreSQLParserVIEWS, PostgreSQLParserNORMALIZE, PostgreSQLParserDUMP, PostgreSQLParserPRINT_STRICT_PARAMS, PostgreSQLParserVARIABLE_CONFLICT, PostgreSQLParserERROR, PostgreSQLParserUSE_VARIABLE, PostgreSQLParserUSE_COLUMN, PostgreSQLParserALIAS, PostgreSQLParserCONSTANT, PostgreSQLParserPERFORM, PostgreSQLParserGET, PostgreSQLParserDIAGNOSTICS, PostgreSQLParserSTACKED, PostgreSQLParserELSIF, PostgreSQLParserREVERSE, PostgreSQLParserSLICE, PostgreSQLParserEXIT, PostgreSQLParserRETURN, PostgreSQLParserQUERY, PostgreSQLParserRAISE, PostgreSQLParserSQLSTATE, PostgreSQLParserDEBUG, PostgreSQLParserLOG, PostgreSQLParserINFO, PostgreSQLParserNOTICE, PostgreSQLParserWARNING, PostgreSQLParserEXCEPTION, PostgreSQLParserASSERT, PostgreSQLParserOPEN, PostgreSQLParserABS, PostgreSQLParserCBRT, PostgreSQLParserCEIL, PostgreSQLParserCEILING, PostgreSQLParserDEGREES, PostgreSQLParserDIV, PostgreSQLParserEXP, PostgreSQLParserFACTORIAL, PostgreSQLParserFLOOR, PostgreSQLParserGCD, PostgreSQLParserLCM, PostgreSQLParserLN, PostgreSQLParserLOG10, PostgreSQLParserMIN_SCALE, PostgreSQLParserMOD, PostgreSQLParserPI, PostgreSQLParserPOWER, PostgreSQLParserRADIANS, PostgreSQLParserROUND, PostgreSQLParserSCALE, PostgreSQLParserSIGN, PostgreSQLParserSQRT, PostgreSQLParserTRIM_SCALE, PostgreSQLParserTRUNC, PostgreSQLParserWIDTH_BUCKET, PostgreSQLParserRANDOM, PostgreSQLParserSETSEED, PostgreSQLParserACOS, PostgreSQLParserACOSD, PostgreSQLParserASIN, PostgreSQLParserASIND, PostgreSQLParserATAN, PostgreSQLParserATAND, PostgreSQLParserATAN2, PostgreSQLParserATAN2D, PostgreSQLParserCOS, PostgreSQLParserCOSD, PostgreSQLParserCOT, PostgreSQLParserCOTD, PostgreSQLParserSIN, PostgreSQLParserSIND, PostgreSQLParserTAN, PostgreSQLParserTAND, PostgreSQLParserSINH, PostgreSQLParserCOSH, PostgreSQLParserTANH, PostgreSQLParserASINH, PostgreSQLParserACOSH, PostgreSQLParserATANH, PostgreSQLParserBIT_LENGTH, PostgreSQLParserCHAR_LENGTH, PostgreSQLParserCHARACTER_LENGTH, PostgreSQLParserLOWER, PostgreSQLParserOCTET_LENGTH, PostgreSQLParserUPPER, PostgreSQLParserASCII, PostgreSQLParserBTRIM, PostgreSQLParserCHR, PostgreSQLParserCONCAT, PostgreSQLParserCONCAT_WS, PostgreSQLParserFORMAT, PostgreSQLParserINITCAP, PostgreSQLParserLENGTH, PostgreSQLParserLPAD, PostgreSQLParserLTRIM, PostgreSQLParserMD5, PostgreSQLParserPARSE_IDENT, PostgreSQLParserPG_CLIENT_ENCODING, PostgreSQLParserQUOTE_IDENT, PostgreSQLParserQUOTE_LITERAL, PostgreSQLParserQUOTE_NULLABLE, PostgreSQLParserREGEXP_COUNT, PostgreSQLParserREGEXP_INSTR, PostgreSQLParserREGEXP_LIKE, PostgreSQLParserREGEXP_MATCH, PostgreSQLParserREGEXP_MATCHES, PostgreSQLParserREGEXP_REPLACE, PostgreSQLParserREGEXP_SPLIT_TO_ARRAY, PostgreSQLParserREGEXP_SPLIT_TO_TABLE, PostgreSQLParserREGEXP_SUBSTR, PostgreSQLParserREPEAT, PostgreSQLParserRPAD, PostgreSQLParserRTRIM, PostgreSQLParserSPLIT_PART, PostgreSQLParserSTARTS_WITH, PostgreSQLParserSTRING_TO_ARRAY, PostgreSQLParserSTRING_TO_TABLE, PostgreSQLParserSTRPOS, PostgreSQLParserSUBSTR, PostgreSQLParserTO_ASCII, PostgreSQLParserTO_HEX, PostgreSQLParserTRANSLATE, PostgreSQLParserUNISTR, PostgreSQLParserAGE, PostgreSQLParserCLOCK_TIMESTAMP, PostgreSQLParserDATE_BIN, PostgreSQLParserDATE_PART, PostgreSQLParserDATE_TRUNC, PostgreSQLParserISFINITE, PostgreSQLParserJUSTIFY_DAYS, PostgreSQLParserJUSTIFY_HOURS, PostgreSQLParserJUSTIFY_INTERVAL, PostgreSQLParserMAKE_DATE, PostgreSQLParserMAKE_INTERVAL, PostgreSQLParserMAKE_TIME, PostgreSQLParserMAKE_TIMESTAMP, PostgreSQLParserMAKE_TIMESTAMPTZ, PostgreSQLParserNOW, PostgreSQLParserSTATEMENT_TIMESTAMP, PostgreSQLParserTIMEOFDAY, PostgreSQLParserTRANSACTION_TIMESTAMP, PostgreSQLParserTO_TIMESTAMP, PostgreSQLParserTO_CHAR, PostgreSQLParserTO_DATE, PostgreSQLParserTO_NUMBER, PostgreSQLParserIdentifier, PostgreSQLParserQuotedIdentifier, PostgreSQLParserUnicodeQuotedIdentifier, PostgreSQLParserPLSQLVARIABLENAME, PostgreSQLParserPLSQLIDENTIFIER:
		{
			p.SetState(10199)
			p.Any_name()
		}

	case PostgreSQLParserPARAM:
		{
			p.SetState(10200)
			p.Match(PostgreSQLParserPARAM)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	default:
		p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		goto errorExit
	}
	p.SetState(10209)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}
	_la = p.GetTokenStream().LA(1)

	for _la == PostgreSQLParserOPEN_BRACKET {
		{
			p.SetState(10203)
			p.Match(PostgreSQLParserOPEN_BRACKET)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(10204)
			p.Expr_until_rightbracket()
		}
		{
			p.SetState(10205)
			p.Match(PostgreSQLParserCLOSE_BRACKET)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

		p.SetState(10211)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}
		_la = p.GetTokenStream().LA(1)
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IStmt_ifContext is an interface to support dynamic dispatch.
type IStmt_ifContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	AllIF_P() []antlr.TerminalNode
	IF_P(i int) antlr.TerminalNode
	Expr_until_then() IExpr_until_thenContext
	THEN() antlr.TerminalNode
	Proc_sect() IProc_sectContext
	Stmt_elsifs() IStmt_elsifsContext
	Stmt_else() IStmt_elseContext
	END_P() antlr.TerminalNode
	SEMI() antlr.TerminalNode

	// IsStmt_ifContext differentiates from other interfaces.
	IsStmt_ifContext()
}

type Stmt_ifContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyStmt_ifContext() *Stmt_ifContext {
	var p = new(Stmt_ifContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_stmt_if
	return p
}

func InitEmptyStmt_ifContext(p *Stmt_ifContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_stmt_if
}

func (*Stmt_ifContext) IsStmt_ifContext() {}

func NewStmt_ifContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Stmt_ifContext {
	var p = new(Stmt_ifContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_stmt_if

	return p
}

func (s *Stmt_ifContext) GetParser() antlr.Parser { return s.parser }

func (s *Stmt_ifContext) AllIF_P() []antlr.TerminalNode {
	return s.GetTokens(PostgreSQLParserIF_P)
}

func (s *Stmt_ifContext) IF_P(i int) antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserIF_P, i)
}

func (s *Stmt_ifContext) Expr_until_then() IExpr_until_thenContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IExpr_until_thenContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IExpr_until_thenContext)
}

func (s *Stmt_ifContext) THEN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserTHEN, 0)
}

func (s *Stmt_ifContext) Proc_sect() IProc_sectContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IProc_sectContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IProc_sectContext)
}

func (s *Stmt_ifContext) Stmt_elsifs() IStmt_elsifsContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IStmt_elsifsContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IStmt_elsifsContext)
}

func (s *Stmt_ifContext) Stmt_else() IStmt_elseContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IStmt_elseContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IStmt_elseContext)
}

func (s *Stmt_ifContext) END_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserEND_P, 0)
}

func (s *Stmt_ifContext) SEMI() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserSEMI, 0)
}

func (s *Stmt_ifContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Stmt_ifContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Stmt_ifContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterStmt_if(s)
	}
}

func (s *Stmt_ifContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitStmt_if(s)
	}
}

func (s *Stmt_ifContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitStmt_if(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Stmt_if() (localctx IStmt_ifContext) {
	localctx = NewStmt_ifContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1478, PostgreSQLParserRULE_stmt_if)
	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(10212)
		p.Match(PostgreSQLParserIF_P)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(10213)
		p.Expr_until_then()
	}
	{
		p.SetState(10214)
		p.Match(PostgreSQLParserTHEN)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(10215)
		p.Proc_sect()
	}
	{
		p.SetState(10216)
		p.Stmt_elsifs()
	}
	{
		p.SetState(10217)
		p.Stmt_else()
	}
	{
		p.SetState(10218)
		p.Match(PostgreSQLParserEND_P)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(10219)
		p.Match(PostgreSQLParserIF_P)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(10220)
		p.Match(PostgreSQLParserSEMI)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IStmt_elsifsContext is an interface to support dynamic dispatch.
type IStmt_elsifsContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	AllELSIF() []antlr.TerminalNode
	ELSIF(i int) antlr.TerminalNode
	AllA_expr() []IA_exprContext
	A_expr(i int) IA_exprContext
	AllTHEN() []antlr.TerminalNode
	THEN(i int) antlr.TerminalNode
	AllProc_sect() []IProc_sectContext
	Proc_sect(i int) IProc_sectContext

	// IsStmt_elsifsContext differentiates from other interfaces.
	IsStmt_elsifsContext()
}

type Stmt_elsifsContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyStmt_elsifsContext() *Stmt_elsifsContext {
	var p = new(Stmt_elsifsContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_stmt_elsifs
	return p
}

func InitEmptyStmt_elsifsContext(p *Stmt_elsifsContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_stmt_elsifs
}

func (*Stmt_elsifsContext) IsStmt_elsifsContext() {}

func NewStmt_elsifsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Stmt_elsifsContext {
	var p = new(Stmt_elsifsContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_stmt_elsifs

	return p
}

func (s *Stmt_elsifsContext) GetParser() antlr.Parser { return s.parser }

func (s *Stmt_elsifsContext) AllELSIF() []antlr.TerminalNode {
	return s.GetTokens(PostgreSQLParserELSIF)
}

func (s *Stmt_elsifsContext) ELSIF(i int) antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserELSIF, i)
}

func (s *Stmt_elsifsContext) AllA_expr() []IA_exprContext {
	children := s.GetChildren()
	len := 0
	for _, ctx := range children {
		if _, ok := ctx.(IA_exprContext); ok {
			len++
		}
	}

	tst := make([]IA_exprContext, len)
	i := 0
	for _, ctx := range children {
		if t, ok := ctx.(IA_exprContext); ok {
			tst[i] = t.(IA_exprContext)
			i++
		}
	}

	return tst
}

func (s *Stmt_elsifsContext) A_expr(i int) IA_exprContext {
	var t antlr.RuleContext
	j := 0
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IA_exprContext); ok {
			if j == i {
				t = ctx.(antlr.RuleContext)
				break
			}
			j++
		}
	}

	if t == nil {
		return nil
	}

	return t.(IA_exprContext)
}

func (s *Stmt_elsifsContext) AllTHEN() []antlr.TerminalNode {
	return s.GetTokens(PostgreSQLParserTHEN)
}

func (s *Stmt_elsifsContext) THEN(i int) antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserTHEN, i)
}

func (s *Stmt_elsifsContext) AllProc_sect() []IProc_sectContext {
	children := s.GetChildren()
	len := 0
	for _, ctx := range children {
		if _, ok := ctx.(IProc_sectContext); ok {
			len++
		}
	}

	tst := make([]IProc_sectContext, len)
	i := 0
	for _, ctx := range children {
		if t, ok := ctx.(IProc_sectContext); ok {
			tst[i] = t.(IProc_sectContext)
			i++
		}
	}

	return tst
}

func (s *Stmt_elsifsContext) Proc_sect(i int) IProc_sectContext {
	var t antlr.RuleContext
	j := 0
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IProc_sectContext); ok {
			if j == i {
				t = ctx.(antlr.RuleContext)
				break
			}
			j++
		}
	}

	if t == nil {
		return nil
	}

	return t.(IProc_sectContext)
}

func (s *Stmt_elsifsContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Stmt_elsifsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Stmt_elsifsContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterStmt_elsifs(s)
	}
}

func (s *Stmt_elsifsContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitStmt_elsifs(s)
	}
}

func (s *Stmt_elsifsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitStmt_elsifs(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Stmt_elsifs() (localctx IStmt_elsifsContext) {
	localctx = NewStmt_elsifsContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1480, PostgreSQLParserRULE_stmt_elsifs)
	var _la int

	p.EnterOuterAlt(localctx, 1)
	p.SetState(10229)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}
	_la = p.GetTokenStream().LA(1)

	for _la == PostgreSQLParserELSIF {
		{
			p.SetState(10222)
			p.Match(PostgreSQLParserELSIF)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(10223)
			p.A_expr()
		}
		{
			p.SetState(10224)
			p.Match(PostgreSQLParserTHEN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(10225)
			p.Proc_sect()
		}

		p.SetState(10231)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}
		_la = p.GetTokenStream().LA(1)
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IStmt_elseContext is an interface to support dynamic dispatch.
type IStmt_elseContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	ELSE() antlr.TerminalNode
	Proc_sect() IProc_sectContext

	// IsStmt_elseContext differentiates from other interfaces.
	IsStmt_elseContext()
}

type Stmt_elseContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyStmt_elseContext() *Stmt_elseContext {
	var p = new(Stmt_elseContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_stmt_else
	return p
}

func InitEmptyStmt_elseContext(p *Stmt_elseContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_stmt_else
}

func (*Stmt_elseContext) IsStmt_elseContext() {}

func NewStmt_elseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Stmt_elseContext {
	var p = new(Stmt_elseContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_stmt_else

	return p
}

func (s *Stmt_elseContext) GetParser() antlr.Parser { return s.parser }

func (s *Stmt_elseContext) ELSE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserELSE, 0)
}

func (s *Stmt_elseContext) Proc_sect() IProc_sectContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IProc_sectContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IProc_sectContext)
}

func (s *Stmt_elseContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Stmt_elseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Stmt_elseContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterStmt_else(s)
	}
}

func (s *Stmt_elseContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitStmt_else(s)
	}
}

func (s *Stmt_elseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitStmt_else(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Stmt_else() (localctx IStmt_elseContext) {
	localctx = NewStmt_elseContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1482, PostgreSQLParserRULE_stmt_else)
	p.SetState(10235)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetTokenStream().LA(1) {
	case PostgreSQLParserEND_P:
		p.EnterOuterAlt(localctx, 1)

	case PostgreSQLParserELSE:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(10233)
			p.Match(PostgreSQLParserELSE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(10234)
			p.Proc_sect()
		}

	default:
		p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IStmt_caseContext is an interface to support dynamic dispatch.
type IStmt_caseContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	AllCASE() []antlr.TerminalNode
	CASE(i int) antlr.TerminalNode
	Opt_expr_until_when() IOpt_expr_until_whenContext
	Case_when_list() ICase_when_listContext
	Opt_case_else() IOpt_case_elseContext
	END_P() antlr.TerminalNode
	SEMI() antlr.TerminalNode

	// IsStmt_caseContext differentiates from other interfaces.
	IsStmt_caseContext()
}

type Stmt_caseContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyStmt_caseContext() *Stmt_caseContext {
	var p = new(Stmt_caseContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_stmt_case
	return p
}

func InitEmptyStmt_caseContext(p *Stmt_caseContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_stmt_case
}

func (*Stmt_caseContext) IsStmt_caseContext() {}

func NewStmt_caseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Stmt_caseContext {
	var p = new(Stmt_caseContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_stmt_case

	return p
}

func (s *Stmt_caseContext) GetParser() antlr.Parser { return s.parser }

func (s *Stmt_caseContext) AllCASE() []antlr.TerminalNode {
	return s.GetTokens(PostgreSQLParserCASE)
}

func (s *Stmt_caseContext) CASE(i int) antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCASE, i)
}

func (s *Stmt_caseContext) Opt_expr_until_when() IOpt_expr_until_whenContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOpt_expr_until_whenContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOpt_expr_until_whenContext)
}

func (s *Stmt_caseContext) Case_when_list() ICase_when_listContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ICase_when_listContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ICase_when_listContext)
}

func (s *Stmt_caseContext) Opt_case_else() IOpt_case_elseContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOpt_case_elseContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOpt_case_elseContext)
}

func (s *Stmt_caseContext) END_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserEND_P, 0)
}

func (s *Stmt_caseContext) SEMI() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserSEMI, 0)
}

func (s *Stmt_caseContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Stmt_caseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Stmt_caseContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterStmt_case(s)
	}
}

func (s *Stmt_caseContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitStmt_case(s)
	}
}

func (s *Stmt_caseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitStmt_case(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Stmt_case() (localctx IStmt_caseContext) {
	localctx = NewStmt_caseContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1484, PostgreSQLParserRULE_stmt_case)
	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(10237)
		p.Match(PostgreSQLParserCASE)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(10238)
		p.Opt_expr_until_when()
	}
	{
		p.SetState(10239)
		p.Case_when_list()
	}
	{
		p.SetState(10240)
		p.Opt_case_else()
	}
	{
		p.SetState(10241)
		p.Match(PostgreSQLParserEND_P)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(10242)
		p.Match(PostgreSQLParserCASE)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(10243)
		p.Match(PostgreSQLParserSEMI)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IOpt_expr_until_whenContext is an interface to support dynamic dispatch.
type IOpt_expr_until_whenContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Sql_expression() ISql_expressionContext

	// IsOpt_expr_until_whenContext differentiates from other interfaces.
	IsOpt_expr_until_whenContext()
}

type Opt_expr_until_whenContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyOpt_expr_until_whenContext() *Opt_expr_until_whenContext {
	var p = new(Opt_expr_until_whenContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opt_expr_until_when
	return p
}

func InitEmptyOpt_expr_until_whenContext(p *Opt_expr_until_whenContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opt_expr_until_when
}

func (*Opt_expr_until_whenContext) IsOpt_expr_until_whenContext() {}

func NewOpt_expr_until_whenContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_expr_until_whenContext {
	var p = new(Opt_expr_until_whenContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_opt_expr_until_when

	return p
}

func (s *Opt_expr_until_whenContext) GetParser() antlr.Parser { return s.parser }

func (s *Opt_expr_until_whenContext) Sql_expression() ISql_expressionContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ISql_expressionContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ISql_expressionContext)
}

func (s *Opt_expr_until_whenContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Opt_expr_until_whenContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Opt_expr_until_whenContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterOpt_expr_until_when(s)
	}
}

func (s *Opt_expr_until_whenContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitOpt_expr_until_when(s)
	}
}

func (s *Opt_expr_until_whenContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitOpt_expr_until_when(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Opt_expr_until_when() (localctx IOpt_expr_until_whenContext) {
	localctx = NewOpt_expr_until_whenContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1486, PostgreSQLParserRULE_opt_expr_until_when)
	p.SetState(10247)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 693, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(10246)
			p.Sql_expression()
		}

	case antlr.ATNInvalidAltNumber:
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// ICase_when_listContext is an interface to support dynamic dispatch.
type ICase_when_listContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	AllCase_when() []ICase_whenContext
	Case_when(i int) ICase_whenContext

	// IsCase_when_listContext differentiates from other interfaces.
	IsCase_when_listContext()
}

type Case_when_listContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyCase_when_listContext() *Case_when_listContext {
	var p = new(Case_when_listContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_case_when_list
	return p
}

func InitEmptyCase_when_listContext(p *Case_when_listContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_case_when_list
}

func (*Case_when_listContext) IsCase_when_listContext() {}

func NewCase_when_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Case_when_listContext {
	var p = new(Case_when_listContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_case_when_list

	return p
}

func (s *Case_when_listContext) GetParser() antlr.Parser { return s.parser }

func (s *Case_when_listContext) AllCase_when() []ICase_whenContext {
	children := s.GetChildren()
	len := 0
	for _, ctx := range children {
		if _, ok := ctx.(ICase_whenContext); ok {
			len++
		}
	}

	tst := make([]ICase_whenContext, len)
	i := 0
	for _, ctx := range children {
		if t, ok := ctx.(ICase_whenContext); ok {
			tst[i] = t.(ICase_whenContext)
			i++
		}
	}

	return tst
}

func (s *Case_when_listContext) Case_when(i int) ICase_whenContext {
	var t antlr.RuleContext
	j := 0
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ICase_whenContext); ok {
			if j == i {
				t = ctx.(antlr.RuleContext)
				break
			}
			j++
		}
	}

	if t == nil {
		return nil
	}

	return t.(ICase_whenContext)
}

func (s *Case_when_listContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Case_when_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Case_when_listContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterCase_when_list(s)
	}
}

func (s *Case_when_listContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitCase_when_list(s)
	}
}

func (s *Case_when_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitCase_when_list(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Case_when_list() (localctx ICase_when_listContext) {
	localctx = NewCase_when_listContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1488, PostgreSQLParserRULE_case_when_list)
	var _la int

	p.EnterOuterAlt(localctx, 1)
	p.SetState(10250)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}
	_la = p.GetTokenStream().LA(1)

	for ok := true; ok; ok = _la == PostgreSQLParserWHEN {
		{
			p.SetState(10249)
			p.Case_when()
		}

		p.SetState(10252)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}
		_la = p.GetTokenStream().LA(1)
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// ICase_whenContext is an interface to support dynamic dispatch.
type ICase_whenContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	WHEN() antlr.TerminalNode
	Expr_list() IExpr_listContext
	THEN() antlr.TerminalNode
	Proc_sect() IProc_sectContext

	// IsCase_whenContext differentiates from other interfaces.
	IsCase_whenContext()
}

type Case_whenContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyCase_whenContext() *Case_whenContext {
	var p = new(Case_whenContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_case_when
	return p
}

func InitEmptyCase_whenContext(p *Case_whenContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_case_when
}

func (*Case_whenContext) IsCase_whenContext() {}

func NewCase_whenContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Case_whenContext {
	var p = new(Case_whenContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_case_when

	return p
}

func (s *Case_whenContext) GetParser() antlr.Parser { return s.parser }

func (s *Case_whenContext) WHEN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserWHEN, 0)
}

func (s *Case_whenContext) Expr_list() IExpr_listContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IExpr_listContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IExpr_listContext)
}

func (s *Case_whenContext) THEN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserTHEN, 0)
}

func (s *Case_whenContext) Proc_sect() IProc_sectContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IProc_sectContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IProc_sectContext)
}

func (s *Case_whenContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Case_whenContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Case_whenContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterCase_when(s)
	}
}

func (s *Case_whenContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitCase_when(s)
	}
}

func (s *Case_whenContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitCase_when(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Case_when() (localctx ICase_whenContext) {
	localctx = NewCase_whenContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1490, PostgreSQLParserRULE_case_when)
	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(10254)
		p.Match(PostgreSQLParserWHEN)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(10255)
		p.Expr_list()
	}
	{
		p.SetState(10256)
		p.Match(PostgreSQLParserTHEN)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(10257)
		p.Proc_sect()
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IOpt_case_elseContext is an interface to support dynamic dispatch.
type IOpt_case_elseContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	ELSE() antlr.TerminalNode
	Proc_sect() IProc_sectContext

	// IsOpt_case_elseContext differentiates from other interfaces.
	IsOpt_case_elseContext()
}

type Opt_case_elseContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyOpt_case_elseContext() *Opt_case_elseContext {
	var p = new(Opt_case_elseContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opt_case_else
	return p
}

func InitEmptyOpt_case_elseContext(p *Opt_case_elseContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opt_case_else
}

func (*Opt_case_elseContext) IsOpt_case_elseContext() {}

func NewOpt_case_elseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_case_elseContext {
	var p = new(Opt_case_elseContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_opt_case_else

	return p
}

func (s *Opt_case_elseContext) GetParser() antlr.Parser { return s.parser }

func (s *Opt_case_elseContext) ELSE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserELSE, 0)
}

func (s *Opt_case_elseContext) Proc_sect() IProc_sectContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IProc_sectContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IProc_sectContext)
}

func (s *Opt_case_elseContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Opt_case_elseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Opt_case_elseContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterOpt_case_else(s)
	}
}

func (s *Opt_case_elseContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitOpt_case_else(s)
	}
}

func (s *Opt_case_elseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitOpt_case_else(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Opt_case_else() (localctx IOpt_case_elseContext) {
	localctx = NewOpt_case_elseContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1492, PostgreSQLParserRULE_opt_case_else)
	p.SetState(10262)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetTokenStream().LA(1) {
	case PostgreSQLParserEND_P:
		p.EnterOuterAlt(localctx, 1)

	case PostgreSQLParserELSE:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(10260)
			p.Match(PostgreSQLParserELSE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(10261)
			p.Proc_sect()
		}

	default:
		p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IStmt_loopContext is an interface to support dynamic dispatch.
type IStmt_loopContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Opt_loop_label() IOpt_loop_labelContext
	Loop_body() ILoop_bodyContext

	// IsStmt_loopContext differentiates from other interfaces.
	IsStmt_loopContext()
}

type Stmt_loopContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyStmt_loopContext() *Stmt_loopContext {
	var p = new(Stmt_loopContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_stmt_loop
	return p
}

func InitEmptyStmt_loopContext(p *Stmt_loopContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_stmt_loop
}

func (*Stmt_loopContext) IsStmt_loopContext() {}

func NewStmt_loopContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Stmt_loopContext {
	var p = new(Stmt_loopContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_stmt_loop

	return p
}

func (s *Stmt_loopContext) GetParser() antlr.Parser { return s.parser }

func (s *Stmt_loopContext) Opt_loop_label() IOpt_loop_labelContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOpt_loop_labelContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOpt_loop_labelContext)
}

func (s *Stmt_loopContext) Loop_body() ILoop_bodyContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ILoop_bodyContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ILoop_bodyContext)
}

func (s *Stmt_loopContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Stmt_loopContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Stmt_loopContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterStmt_loop(s)
	}
}

func (s *Stmt_loopContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitStmt_loop(s)
	}
}

func (s *Stmt_loopContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitStmt_loop(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Stmt_loop() (localctx IStmt_loopContext) {
	localctx = NewStmt_loopContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1494, PostgreSQLParserRULE_stmt_loop)
	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(10264)
		p.Opt_loop_label()
	}
	{
		p.SetState(10265)
		p.Loop_body()
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IStmt_whileContext is an interface to support dynamic dispatch.
type IStmt_whileContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Opt_loop_label() IOpt_loop_labelContext
	WHILE() antlr.TerminalNode
	Expr_until_loop() IExpr_until_loopContext
	Loop_body() ILoop_bodyContext

	// IsStmt_whileContext differentiates from other interfaces.
	IsStmt_whileContext()
}

type Stmt_whileContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyStmt_whileContext() *Stmt_whileContext {
	var p = new(Stmt_whileContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_stmt_while
	return p
}

func InitEmptyStmt_whileContext(p *Stmt_whileContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_stmt_while
}

func (*Stmt_whileContext) IsStmt_whileContext() {}

func NewStmt_whileContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Stmt_whileContext {
	var p = new(Stmt_whileContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_stmt_while

	return p
}

func (s *Stmt_whileContext) GetParser() antlr.Parser { return s.parser }

func (s *Stmt_whileContext) Opt_loop_label() IOpt_loop_labelContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOpt_loop_labelContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOpt_loop_labelContext)
}

func (s *Stmt_whileContext) WHILE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserWHILE, 0)
}

func (s *Stmt_whileContext) Expr_until_loop() IExpr_until_loopContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IExpr_until_loopContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IExpr_until_loopContext)
}

func (s *Stmt_whileContext) Loop_body() ILoop_bodyContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ILoop_bodyContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ILoop_bodyContext)
}

func (s *Stmt_whileContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Stmt_whileContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Stmt_whileContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterStmt_while(s)
	}
}

func (s *Stmt_whileContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitStmt_while(s)
	}
}

func (s *Stmt_whileContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitStmt_while(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Stmt_while() (localctx IStmt_whileContext) {
	localctx = NewStmt_whileContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1496, PostgreSQLParserRULE_stmt_while)
	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(10267)
		p.Opt_loop_label()
	}
	{
		p.SetState(10268)
		p.Match(PostgreSQLParserWHILE)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(10269)
		p.Expr_until_loop()
	}
	{
		p.SetState(10270)
		p.Loop_body()
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IStmt_forContext is an interface to support dynamic dispatch.
type IStmt_forContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Opt_loop_label() IOpt_loop_labelContext
	FOR() antlr.TerminalNode
	For_control() IFor_controlContext
	Loop_body() ILoop_bodyContext

	// IsStmt_forContext differentiates from other interfaces.
	IsStmt_forContext()
}

type Stmt_forContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyStmt_forContext() *Stmt_forContext {
	var p = new(Stmt_forContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_stmt_for
	return p
}

func InitEmptyStmt_forContext(p *Stmt_forContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_stmt_for
}

func (*Stmt_forContext) IsStmt_forContext() {}

func NewStmt_forContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Stmt_forContext {
	var p = new(Stmt_forContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_stmt_for

	return p
}

func (s *Stmt_forContext) GetParser() antlr.Parser { return s.parser }

func (s *Stmt_forContext) Opt_loop_label() IOpt_loop_labelContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOpt_loop_labelContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOpt_loop_labelContext)
}

func (s *Stmt_forContext) FOR() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserFOR, 0)
}

func (s *Stmt_forContext) For_control() IFor_controlContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IFor_controlContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IFor_controlContext)
}

func (s *Stmt_forContext) Loop_body() ILoop_bodyContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ILoop_bodyContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ILoop_bodyContext)
}

func (s *Stmt_forContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Stmt_forContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Stmt_forContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterStmt_for(s)
	}
}

func (s *Stmt_forContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitStmt_for(s)
	}
}

func (s *Stmt_forContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitStmt_for(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Stmt_for() (localctx IStmt_forContext) {
	localctx = NewStmt_forContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1498, PostgreSQLParserRULE_stmt_for)
	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(10272)
		p.Opt_loop_label()
	}
	{
		p.SetState(10273)
		p.Match(PostgreSQLParserFOR)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(10274)
		p.For_control()
	}
	{
		p.SetState(10275)
		p.Loop_body()
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IFor_controlContext is an interface to support dynamic dispatch.
type IFor_controlContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	For_variable() IFor_variableContext
	IN_P() antlr.TerminalNode
	Cursor_name() ICursor_nameContext
	Opt_cursor_parameters() IOpt_cursor_parametersContext
	Selectstmt() ISelectstmtContext
	Explainstmt() IExplainstmtContext
	EXECUTE() antlr.TerminalNode
	AllA_expr() []IA_exprContext
	A_expr(i int) IA_exprContext
	Opt_for_using_expression() IOpt_for_using_expressionContext
	Opt_reverse() IOpt_reverseContext
	DOT_DOT() antlr.TerminalNode
	Opt_by_expression() IOpt_by_expressionContext

	// IsFor_controlContext differentiates from other interfaces.
	IsFor_controlContext()
}

type For_controlContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyFor_controlContext() *For_controlContext {
	var p = new(For_controlContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_for_control
	return p
}

func InitEmptyFor_controlContext(p *For_controlContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_for_control
}

func (*For_controlContext) IsFor_controlContext() {}

func NewFor_controlContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *For_controlContext {
	var p = new(For_controlContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_for_control

	return p
}

func (s *For_controlContext) GetParser() antlr.Parser { return s.parser }

func (s *For_controlContext) For_variable() IFor_variableContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IFor_variableContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IFor_variableContext)
}

func (s *For_controlContext) IN_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserIN_P, 0)
}

func (s *For_controlContext) Cursor_name() ICursor_nameContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ICursor_nameContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ICursor_nameContext)
}

func (s *For_controlContext) Opt_cursor_parameters() IOpt_cursor_parametersContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOpt_cursor_parametersContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOpt_cursor_parametersContext)
}

func (s *For_controlContext) Selectstmt() ISelectstmtContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ISelectstmtContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ISelectstmtContext)
}

func (s *For_controlContext) Explainstmt() IExplainstmtContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IExplainstmtContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IExplainstmtContext)
}

func (s *For_controlContext) EXECUTE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserEXECUTE, 0)
}

func (s *For_controlContext) AllA_expr() []IA_exprContext {
	children := s.GetChildren()
	len := 0
	for _, ctx := range children {
		if _, ok := ctx.(IA_exprContext); ok {
			len++
		}
	}

	tst := make([]IA_exprContext, len)
	i := 0
	for _, ctx := range children {
		if t, ok := ctx.(IA_exprContext); ok {
			tst[i] = t.(IA_exprContext)
			i++
		}
	}

	return tst
}

func (s *For_controlContext) A_expr(i int) IA_exprContext {
	var t antlr.RuleContext
	j := 0
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IA_exprContext); ok {
			if j == i {
				t = ctx.(antlr.RuleContext)
				break
			}
			j++
		}
	}

	if t == nil {
		return nil
	}

	return t.(IA_exprContext)
}

func (s *For_controlContext) Opt_for_using_expression() IOpt_for_using_expressionContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOpt_for_using_expressionContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOpt_for_using_expressionContext)
}

func (s *For_controlContext) Opt_reverse() IOpt_reverseContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOpt_reverseContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOpt_reverseContext)
}

func (s *For_controlContext) DOT_DOT() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserDOT_DOT, 0)
}

func (s *For_controlContext) Opt_by_expression() IOpt_by_expressionContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOpt_by_expressionContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOpt_by_expressionContext)
}

func (s *For_controlContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *For_controlContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *For_controlContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterFor_control(s)
	}
}

func (s *For_controlContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitFor_control(s)
	}
}

func (s *For_controlContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitFor_control(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) For_control() (localctx IFor_controlContext) {
	localctx = NewFor_controlContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1500, PostgreSQLParserRULE_for_control)
	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(10277)
		p.For_variable()
	}
	{
		p.SetState(10278)
		p.Match(PostgreSQLParserIN_P)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	p.SetState(10294)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 696, p.GetParserRuleContext()) {
	case 1:
		{
			p.SetState(10279)
			p.Cursor_name()
		}
		{
			p.SetState(10280)
			p.Opt_cursor_parameters()
		}

	case 2:
		{
			p.SetState(10282)
			p.Selectstmt()
		}

	case 3:
		{
			p.SetState(10283)
			p.Explainstmt()
		}

	case 4:
		{
			p.SetState(10284)
			p.Match(PostgreSQLParserEXECUTE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(10285)
			p.A_expr()
		}
		{
			p.SetState(10286)
			p.Opt_for_using_expression()
		}

	case 5:
		{
			p.SetState(10288)
			p.Opt_reverse()
		}
		{
			p.SetState(10289)
			p.A_expr()
		}
		{
			p.SetState(10290)
			p.Match(PostgreSQLParserDOT_DOT)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(10291)
			p.A_expr()
		}
		{
			p.SetState(10292)
			p.Opt_by_expression()
		}

	case antlr.ATNInvalidAltNumber:
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IOpt_for_using_expressionContext is an interface to support dynamic dispatch.
type IOpt_for_using_expressionContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	USING() antlr.TerminalNode
	Expr_list() IExpr_listContext

	// IsOpt_for_using_expressionContext differentiates from other interfaces.
	IsOpt_for_using_expressionContext()
}

type Opt_for_using_expressionContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyOpt_for_using_expressionContext() *Opt_for_using_expressionContext {
	var p = new(Opt_for_using_expressionContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opt_for_using_expression
	return p
}

func InitEmptyOpt_for_using_expressionContext(p *Opt_for_using_expressionContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opt_for_using_expression
}

func (*Opt_for_using_expressionContext) IsOpt_for_using_expressionContext() {}

func NewOpt_for_using_expressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_for_using_expressionContext {
	var p = new(Opt_for_using_expressionContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_opt_for_using_expression

	return p
}

func (s *Opt_for_using_expressionContext) GetParser() antlr.Parser { return s.parser }

func (s *Opt_for_using_expressionContext) USING() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserUSING, 0)
}

func (s *Opt_for_using_expressionContext) Expr_list() IExpr_listContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IExpr_listContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IExpr_listContext)
}

func (s *Opt_for_using_expressionContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Opt_for_using_expressionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Opt_for_using_expressionContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterOpt_for_using_expression(s)
	}
}

func (s *Opt_for_using_expressionContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitOpt_for_using_expression(s)
	}
}

func (s *Opt_for_using_expressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitOpt_for_using_expression(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Opt_for_using_expression() (localctx IOpt_for_using_expressionContext) {
	localctx = NewOpt_for_using_expressionContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1502, PostgreSQLParserRULE_opt_for_using_expression)
	p.SetState(10299)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetTokenStream().LA(1) {
	case PostgreSQLParserSEMI, PostgreSQLParserLOOP:
		p.EnterOuterAlt(localctx, 1)

	case PostgreSQLParserUSING:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(10297)
			p.Match(PostgreSQLParserUSING)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(10298)
			p.Expr_list()
		}

	default:
		p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IOpt_cursor_parametersContext is an interface to support dynamic dispatch.
type IOpt_cursor_parametersContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	OPEN_PAREN() antlr.TerminalNode
	AllA_expr() []IA_exprContext
	A_expr(i int) IA_exprContext
	CLOSE_PAREN() antlr.TerminalNode
	AllCOMMA() []antlr.TerminalNode
	COMMA(i int) antlr.TerminalNode

	// IsOpt_cursor_parametersContext differentiates from other interfaces.
	IsOpt_cursor_parametersContext()
}

type Opt_cursor_parametersContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyOpt_cursor_parametersContext() *Opt_cursor_parametersContext {
	var p = new(Opt_cursor_parametersContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opt_cursor_parameters
	return p
}

func InitEmptyOpt_cursor_parametersContext(p *Opt_cursor_parametersContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opt_cursor_parameters
}

func (*Opt_cursor_parametersContext) IsOpt_cursor_parametersContext() {}

func NewOpt_cursor_parametersContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_cursor_parametersContext {
	var p = new(Opt_cursor_parametersContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_opt_cursor_parameters

	return p
}

func (s *Opt_cursor_parametersContext) GetParser() antlr.Parser { return s.parser }

func (s *Opt_cursor_parametersContext) OPEN_PAREN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserOPEN_PAREN, 0)
}

func (s *Opt_cursor_parametersContext) AllA_expr() []IA_exprContext {
	children := s.GetChildren()
	len := 0
	for _, ctx := range children {
		if _, ok := ctx.(IA_exprContext); ok {
			len++
		}
	}

	tst := make([]IA_exprContext, len)
	i := 0
	for _, ctx := range children {
		if t, ok := ctx.(IA_exprContext); ok {
			tst[i] = t.(IA_exprContext)
			i++
		}
	}

	return tst
}

func (s *Opt_cursor_parametersContext) A_expr(i int) IA_exprContext {
	var t antlr.RuleContext
	j := 0
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IA_exprContext); ok {
			if j == i {
				t = ctx.(antlr.RuleContext)
				break
			}
			j++
		}
	}

	if t == nil {
		return nil
	}

	return t.(IA_exprContext)
}

func (s *Opt_cursor_parametersContext) CLOSE_PAREN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCLOSE_PAREN, 0)
}

func (s *Opt_cursor_parametersContext) AllCOMMA() []antlr.TerminalNode {
	return s.GetTokens(PostgreSQLParserCOMMA)
}

func (s *Opt_cursor_parametersContext) COMMA(i int) antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCOMMA, i)
}

func (s *Opt_cursor_parametersContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Opt_cursor_parametersContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Opt_cursor_parametersContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterOpt_cursor_parameters(s)
	}
}

func (s *Opt_cursor_parametersContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitOpt_cursor_parameters(s)
	}
}

func (s *Opt_cursor_parametersContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitOpt_cursor_parameters(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Opt_cursor_parameters() (localctx IOpt_cursor_parametersContext) {
	localctx = NewOpt_cursor_parametersContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1504, PostgreSQLParserRULE_opt_cursor_parameters)
	var _la int

	p.SetState(10313)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetTokenStream().LA(1) {
	case PostgreSQLParserLOOP:
		p.EnterOuterAlt(localctx, 1)

	case PostgreSQLParserOPEN_PAREN:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(10302)
			p.Match(PostgreSQLParserOPEN_PAREN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(10303)
			p.A_expr()
		}
		p.SetState(10308)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}
		_la = p.GetTokenStream().LA(1)

		for _la == PostgreSQLParserCOMMA {
			{
				p.SetState(10304)
				p.Match(PostgreSQLParserCOMMA)
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}
			{
				p.SetState(10305)
				p.A_expr()
			}

			p.SetState(10310)
			p.GetErrorHandler().Sync(p)
			if p.HasError() {
				goto errorExit
			}
			_la = p.GetTokenStream().LA(1)
		}
		{
			p.SetState(10311)
			p.Match(PostgreSQLParserCLOSE_PAREN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	default:
		p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IOpt_reverseContext is an interface to support dynamic dispatch.
type IOpt_reverseContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	REVERSE() antlr.TerminalNode

	// IsOpt_reverseContext differentiates from other interfaces.
	IsOpt_reverseContext()
}

type Opt_reverseContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyOpt_reverseContext() *Opt_reverseContext {
	var p = new(Opt_reverseContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opt_reverse
	return p
}

func InitEmptyOpt_reverseContext(p *Opt_reverseContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opt_reverse
}

func (*Opt_reverseContext) IsOpt_reverseContext() {}

func NewOpt_reverseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_reverseContext {
	var p = new(Opt_reverseContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_opt_reverse

	return p
}

func (s *Opt_reverseContext) GetParser() antlr.Parser { return s.parser }

func (s *Opt_reverseContext) REVERSE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserREVERSE, 0)
}

func (s *Opt_reverseContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Opt_reverseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Opt_reverseContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterOpt_reverse(s)
	}
}

func (s *Opt_reverseContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitOpt_reverse(s)
	}
}

func (s *Opt_reverseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitOpt_reverse(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Opt_reverse() (localctx IOpt_reverseContext) {
	localctx = NewOpt_reverseContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1506, PostgreSQLParserRULE_opt_reverse)
	p.SetState(10317)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 700, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(10316)
			p.Match(PostgreSQLParserREVERSE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case antlr.ATNInvalidAltNumber:
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IOpt_by_expressionContext is an interface to support dynamic dispatch.
type IOpt_by_expressionContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	BY() antlr.TerminalNode
	A_expr() IA_exprContext

	// IsOpt_by_expressionContext differentiates from other interfaces.
	IsOpt_by_expressionContext()
}

type Opt_by_expressionContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyOpt_by_expressionContext() *Opt_by_expressionContext {
	var p = new(Opt_by_expressionContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opt_by_expression
	return p
}

func InitEmptyOpt_by_expressionContext(p *Opt_by_expressionContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opt_by_expression
}

func (*Opt_by_expressionContext) IsOpt_by_expressionContext() {}

func NewOpt_by_expressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_by_expressionContext {
	var p = new(Opt_by_expressionContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_opt_by_expression

	return p
}

func (s *Opt_by_expressionContext) GetParser() antlr.Parser { return s.parser }

func (s *Opt_by_expressionContext) BY() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserBY, 0)
}

func (s *Opt_by_expressionContext) A_expr() IA_exprContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IA_exprContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IA_exprContext)
}

func (s *Opt_by_expressionContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Opt_by_expressionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Opt_by_expressionContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterOpt_by_expression(s)
	}
}

func (s *Opt_by_expressionContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitOpt_by_expression(s)
	}
}

func (s *Opt_by_expressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitOpt_by_expression(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Opt_by_expression() (localctx IOpt_by_expressionContext) {
	localctx = NewOpt_by_expressionContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1508, PostgreSQLParserRULE_opt_by_expression)
	p.SetState(10322)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetTokenStream().LA(1) {
	case PostgreSQLParserLOOP:
		p.EnterOuterAlt(localctx, 1)

	case PostgreSQLParserBY:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(10320)
			p.Match(PostgreSQLParserBY)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(10321)
			p.A_expr()
		}

	default:
		p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IFor_variableContext is an interface to support dynamic dispatch.
type IFor_variableContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Any_name_list() IAny_name_listContext

	// IsFor_variableContext differentiates from other interfaces.
	IsFor_variableContext()
}

type For_variableContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyFor_variableContext() *For_variableContext {
	var p = new(For_variableContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_for_variable
	return p
}

func InitEmptyFor_variableContext(p *For_variableContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_for_variable
}

func (*For_variableContext) IsFor_variableContext() {}

func NewFor_variableContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *For_variableContext {
	var p = new(For_variableContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_for_variable

	return p
}

func (s *For_variableContext) GetParser() antlr.Parser { return s.parser }

func (s *For_variableContext) Any_name_list() IAny_name_listContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IAny_name_listContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IAny_name_listContext)
}

func (s *For_variableContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *For_variableContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *For_variableContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterFor_variable(s)
	}
}

func (s *For_variableContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitFor_variable(s)
	}
}

func (s *For_variableContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitFor_variable(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) For_variable() (localctx IFor_variableContext) {
	localctx = NewFor_variableContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1510, PostgreSQLParserRULE_for_variable)
	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(10324)
		p.Any_name_list()
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IStmt_foreach_aContext is an interface to support dynamic dispatch.
type IStmt_foreach_aContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Opt_loop_label() IOpt_loop_labelContext
	FOREACH() antlr.TerminalNode
	For_variable() IFor_variableContext
	Foreach_slice() IForeach_sliceContext
	IN_P() antlr.TerminalNode
	ARRAY() antlr.TerminalNode
	A_expr() IA_exprContext
	Loop_body() ILoop_bodyContext

	// IsStmt_foreach_aContext differentiates from other interfaces.
	IsStmt_foreach_aContext()
}

type Stmt_foreach_aContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyStmt_foreach_aContext() *Stmt_foreach_aContext {
	var p = new(Stmt_foreach_aContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_stmt_foreach_a
	return p
}

func InitEmptyStmt_foreach_aContext(p *Stmt_foreach_aContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_stmt_foreach_a
}

func (*Stmt_foreach_aContext) IsStmt_foreach_aContext() {}

func NewStmt_foreach_aContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Stmt_foreach_aContext {
	var p = new(Stmt_foreach_aContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_stmt_foreach_a

	return p
}

func (s *Stmt_foreach_aContext) GetParser() antlr.Parser { return s.parser }

func (s *Stmt_foreach_aContext) Opt_loop_label() IOpt_loop_labelContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOpt_loop_labelContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOpt_loop_labelContext)
}

func (s *Stmt_foreach_aContext) FOREACH() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserFOREACH, 0)
}

func (s *Stmt_foreach_aContext) For_variable() IFor_variableContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IFor_variableContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IFor_variableContext)
}

func (s *Stmt_foreach_aContext) Foreach_slice() IForeach_sliceContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IForeach_sliceContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IForeach_sliceContext)
}

func (s *Stmt_foreach_aContext) IN_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserIN_P, 0)
}

func (s *Stmt_foreach_aContext) ARRAY() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserARRAY, 0)
}

func (s *Stmt_foreach_aContext) A_expr() IA_exprContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IA_exprContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IA_exprContext)
}

func (s *Stmt_foreach_aContext) Loop_body() ILoop_bodyContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ILoop_bodyContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ILoop_bodyContext)
}

func (s *Stmt_foreach_aContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Stmt_foreach_aContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Stmt_foreach_aContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterStmt_foreach_a(s)
	}
}

func (s *Stmt_foreach_aContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitStmt_foreach_a(s)
	}
}

func (s *Stmt_foreach_aContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitStmt_foreach_a(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Stmt_foreach_a() (localctx IStmt_foreach_aContext) {
	localctx = NewStmt_foreach_aContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1512, PostgreSQLParserRULE_stmt_foreach_a)
	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(10326)
		p.Opt_loop_label()
	}
	{
		p.SetState(10327)
		p.Match(PostgreSQLParserFOREACH)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(10328)
		p.For_variable()
	}
	{
		p.SetState(10329)
		p.Foreach_slice()
	}
	{
		p.SetState(10330)
		p.Match(PostgreSQLParserIN_P)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(10331)
		p.Match(PostgreSQLParserARRAY)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(10332)
		p.A_expr()
	}
	{
		p.SetState(10333)
		p.Loop_body()
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IForeach_sliceContext is an interface to support dynamic dispatch.
type IForeach_sliceContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	SLICE() antlr.TerminalNode
	Iconst() IIconstContext

	// IsForeach_sliceContext differentiates from other interfaces.
	IsForeach_sliceContext()
}

type Foreach_sliceContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyForeach_sliceContext() *Foreach_sliceContext {
	var p = new(Foreach_sliceContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_foreach_slice
	return p
}

func InitEmptyForeach_sliceContext(p *Foreach_sliceContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_foreach_slice
}

func (*Foreach_sliceContext) IsForeach_sliceContext() {}

func NewForeach_sliceContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Foreach_sliceContext {
	var p = new(Foreach_sliceContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_foreach_slice

	return p
}

func (s *Foreach_sliceContext) GetParser() antlr.Parser { return s.parser }

func (s *Foreach_sliceContext) SLICE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserSLICE, 0)
}

func (s *Foreach_sliceContext) Iconst() IIconstContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IIconstContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IIconstContext)
}

func (s *Foreach_sliceContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Foreach_sliceContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Foreach_sliceContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterForeach_slice(s)
	}
}

func (s *Foreach_sliceContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitForeach_slice(s)
	}
}

func (s *Foreach_sliceContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitForeach_slice(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Foreach_slice() (localctx IForeach_sliceContext) {
	localctx = NewForeach_sliceContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1514, PostgreSQLParserRULE_foreach_slice)
	p.SetState(10338)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetTokenStream().LA(1) {
	case PostgreSQLParserIN_P:
		p.EnterOuterAlt(localctx, 1)

	case PostgreSQLParserSLICE:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(10336)
			p.Match(PostgreSQLParserSLICE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(10337)
			p.Iconst()
		}

	default:
		p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IStmt_exitContext is an interface to support dynamic dispatch.
type IStmt_exitContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Exit_type() IExit_typeContext
	Opt_label() IOpt_labelContext
	Opt_exitcond() IOpt_exitcondContext
	SEMI() antlr.TerminalNode

	// IsStmt_exitContext differentiates from other interfaces.
	IsStmt_exitContext()
}

type Stmt_exitContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyStmt_exitContext() *Stmt_exitContext {
	var p = new(Stmt_exitContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_stmt_exit
	return p
}

func InitEmptyStmt_exitContext(p *Stmt_exitContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_stmt_exit
}

func (*Stmt_exitContext) IsStmt_exitContext() {}

func NewStmt_exitContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Stmt_exitContext {
	var p = new(Stmt_exitContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_stmt_exit

	return p
}

func (s *Stmt_exitContext) GetParser() antlr.Parser { return s.parser }

func (s *Stmt_exitContext) Exit_type() IExit_typeContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IExit_typeContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IExit_typeContext)
}

func (s *Stmt_exitContext) Opt_label() IOpt_labelContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOpt_labelContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOpt_labelContext)
}

func (s *Stmt_exitContext) Opt_exitcond() IOpt_exitcondContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOpt_exitcondContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOpt_exitcondContext)
}

func (s *Stmt_exitContext) SEMI() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserSEMI, 0)
}

func (s *Stmt_exitContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Stmt_exitContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Stmt_exitContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterStmt_exit(s)
	}
}

func (s *Stmt_exitContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitStmt_exit(s)
	}
}

func (s *Stmt_exitContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitStmt_exit(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Stmt_exit() (localctx IStmt_exitContext) {
	localctx = NewStmt_exitContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1516, PostgreSQLParserRULE_stmt_exit)
	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(10340)
		p.Exit_type()
	}
	{
		p.SetState(10341)
		p.Opt_label()
	}
	{
		p.SetState(10342)
		p.Opt_exitcond()
	}
	{
		p.SetState(10343)
		p.Match(PostgreSQLParserSEMI)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IExit_typeContext is an interface to support dynamic dispatch.
type IExit_typeContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	EXIT() antlr.TerminalNode
	CONTINUE_P() antlr.TerminalNode

	// IsExit_typeContext differentiates from other interfaces.
	IsExit_typeContext()
}

type Exit_typeContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyExit_typeContext() *Exit_typeContext {
	var p = new(Exit_typeContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_exit_type
	return p
}

func InitEmptyExit_typeContext(p *Exit_typeContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_exit_type
}

func (*Exit_typeContext) IsExit_typeContext() {}

func NewExit_typeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Exit_typeContext {
	var p = new(Exit_typeContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_exit_type

	return p
}

func (s *Exit_typeContext) GetParser() antlr.Parser { return s.parser }

func (s *Exit_typeContext) EXIT() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserEXIT, 0)
}

func (s *Exit_typeContext) CONTINUE_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCONTINUE_P, 0)
}

func (s *Exit_typeContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Exit_typeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Exit_typeContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterExit_type(s)
	}
}

func (s *Exit_typeContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitExit_type(s)
	}
}

func (s *Exit_typeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitExit_type(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Exit_type() (localctx IExit_typeContext) {
	localctx = NewExit_typeContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1518, PostgreSQLParserRULE_exit_type)
	var _la int

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(10345)
		_la = p.GetTokenStream().LA(1)

		if !(_la == PostgreSQLParserCONTINUE_P || _la == PostgreSQLParserEXIT) {
			p.GetErrorHandler().RecoverInline(p)
		} else {
			p.GetErrorHandler().ReportMatch(p)
			p.Consume()
		}
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IStmt_returnContext is an interface to support dynamic dispatch.
type IStmt_returnContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	RETURN() antlr.TerminalNode
	SEMI() antlr.TerminalNode
	NEXT() antlr.TerminalNode
	Sql_expression() ISql_expressionContext
	QUERY() antlr.TerminalNode
	Opt_return_result() IOpt_return_resultContext
	EXECUTE() antlr.TerminalNode
	A_expr() IA_exprContext
	Opt_for_using_expression() IOpt_for_using_expressionContext
	Selectstmt() ISelectstmtContext

	// IsStmt_returnContext differentiates from other interfaces.
	IsStmt_returnContext()
}

type Stmt_returnContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyStmt_returnContext() *Stmt_returnContext {
	var p = new(Stmt_returnContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_stmt_return
	return p
}

func InitEmptyStmt_returnContext(p *Stmt_returnContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_stmt_return
}

func (*Stmt_returnContext) IsStmt_returnContext() {}

func NewStmt_returnContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Stmt_returnContext {
	var p = new(Stmt_returnContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_stmt_return

	return p
}

func (s *Stmt_returnContext) GetParser() antlr.Parser { return s.parser }

func (s *Stmt_returnContext) RETURN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserRETURN, 0)
}

func (s *Stmt_returnContext) SEMI() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserSEMI, 0)
}

func (s *Stmt_returnContext) NEXT() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserNEXT, 0)
}

func (s *Stmt_returnContext) Sql_expression() ISql_expressionContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ISql_expressionContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ISql_expressionContext)
}

func (s *Stmt_returnContext) QUERY() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserQUERY, 0)
}

func (s *Stmt_returnContext) Opt_return_result() IOpt_return_resultContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOpt_return_resultContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOpt_return_resultContext)
}

func (s *Stmt_returnContext) EXECUTE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserEXECUTE, 0)
}

func (s *Stmt_returnContext) A_expr() IA_exprContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IA_exprContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IA_exprContext)
}

func (s *Stmt_returnContext) Opt_for_using_expression() IOpt_for_using_expressionContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOpt_for_using_expressionContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOpt_for_using_expressionContext)
}

func (s *Stmt_returnContext) Selectstmt() ISelectstmtContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ISelectstmtContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ISelectstmtContext)
}

func (s *Stmt_returnContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Stmt_returnContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Stmt_returnContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterStmt_return(s)
	}
}

func (s *Stmt_returnContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitStmt_return(s)
	}
}

func (s *Stmt_returnContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitStmt_return(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Stmt_return() (localctx IStmt_returnContext) {
	localctx = NewStmt_returnContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1520, PostgreSQLParserRULE_stmt_return)
	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(10347)
		p.Match(PostgreSQLParserRETURN)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	p.SetState(10359)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 704, p.GetParserRuleContext()) {
	case 1:
		{
			p.SetState(10348)
			p.Match(PostgreSQLParserNEXT)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(10349)
			p.Sql_expression()
		}

	case 2:
		{
			p.SetState(10350)
			p.Match(PostgreSQLParserQUERY)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		p.SetState(10356)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}

		switch p.GetTokenStream().LA(1) {
		case PostgreSQLParserEXECUTE:
			{
				p.SetState(10351)
				p.Match(PostgreSQLParserEXECUTE)
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}
			{
				p.SetState(10352)
				p.A_expr()
			}
			{
				p.SetState(10353)
				p.Opt_for_using_expression()
			}

		case PostgreSQLParserOPEN_PAREN, PostgreSQLParserSELECT, PostgreSQLParserTABLE, PostgreSQLParserWITH, PostgreSQLParserVALUES:
			{
				p.SetState(10355)
				p.Selectstmt()
			}

		default:
			p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
			goto errorExit
		}

	case 3:
		{
			p.SetState(10358)
			p.Opt_return_result()
		}

	case antlr.ATNInvalidAltNumber:
		goto errorExit
	}
	{
		p.SetState(10361)
		p.Match(PostgreSQLParserSEMI)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IOpt_return_resultContext is an interface to support dynamic dispatch.
type IOpt_return_resultContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Sql_expression() ISql_expressionContext

	// IsOpt_return_resultContext differentiates from other interfaces.
	IsOpt_return_resultContext()
}

type Opt_return_resultContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyOpt_return_resultContext() *Opt_return_resultContext {
	var p = new(Opt_return_resultContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opt_return_result
	return p
}

func InitEmptyOpt_return_resultContext(p *Opt_return_resultContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opt_return_result
}

func (*Opt_return_resultContext) IsOpt_return_resultContext() {}

func NewOpt_return_resultContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_return_resultContext {
	var p = new(Opt_return_resultContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_opt_return_result

	return p
}

func (s *Opt_return_resultContext) GetParser() antlr.Parser { return s.parser }

func (s *Opt_return_resultContext) Sql_expression() ISql_expressionContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ISql_expressionContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ISql_expressionContext)
}

func (s *Opt_return_resultContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Opt_return_resultContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Opt_return_resultContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterOpt_return_result(s)
	}
}

func (s *Opt_return_resultContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitOpt_return_result(s)
	}
}

func (s *Opt_return_resultContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitOpt_return_result(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Opt_return_result() (localctx IOpt_return_resultContext) {
	localctx = NewOpt_return_resultContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1522, PostgreSQLParserRULE_opt_return_result)
	p.SetState(10365)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 705, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(10364)
			p.Sql_expression()
		}

	case antlr.ATNInvalidAltNumber:
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IStmt_raiseContext is an interface to support dynamic dispatch.
type IStmt_raiseContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	RAISE() antlr.TerminalNode
	Opt_stmt_raise_level() IOpt_stmt_raise_levelContext
	Sconst() ISconstContext
	Opt_raise_list() IOpt_raise_listContext
	Opt_raise_using() IOpt_raise_usingContext
	SEMI() antlr.TerminalNode
	Identifier() IIdentifierContext
	SQLSTATE() antlr.TerminalNode

	// IsStmt_raiseContext differentiates from other interfaces.
	IsStmt_raiseContext()
}

type Stmt_raiseContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyStmt_raiseContext() *Stmt_raiseContext {
	var p = new(Stmt_raiseContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_stmt_raise
	return p
}

func InitEmptyStmt_raiseContext(p *Stmt_raiseContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_stmt_raise
}

func (*Stmt_raiseContext) IsStmt_raiseContext() {}

func NewStmt_raiseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Stmt_raiseContext {
	var p = new(Stmt_raiseContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_stmt_raise

	return p
}

func (s *Stmt_raiseContext) GetParser() antlr.Parser { return s.parser }

func (s *Stmt_raiseContext) RAISE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserRAISE, 0)
}

func (s *Stmt_raiseContext) Opt_stmt_raise_level() IOpt_stmt_raise_levelContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOpt_stmt_raise_levelContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOpt_stmt_raise_levelContext)
}

func (s *Stmt_raiseContext) Sconst() ISconstContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ISconstContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ISconstContext)
}

func (s *Stmt_raiseContext) Opt_raise_list() IOpt_raise_listContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOpt_raise_listContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOpt_raise_listContext)
}

func (s *Stmt_raiseContext) Opt_raise_using() IOpt_raise_usingContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOpt_raise_usingContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOpt_raise_usingContext)
}

func (s *Stmt_raiseContext) SEMI() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserSEMI, 0)
}

func (s *Stmt_raiseContext) Identifier() IIdentifierContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IIdentifierContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IIdentifierContext)
}

func (s *Stmt_raiseContext) SQLSTATE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserSQLSTATE, 0)
}

func (s *Stmt_raiseContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Stmt_raiseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Stmt_raiseContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterStmt_raise(s)
	}
}

func (s *Stmt_raiseContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitStmt_raise(s)
	}
}

func (s *Stmt_raiseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitStmt_raise(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Stmt_raise() (localctx IStmt_raiseContext) {
	localctx = NewStmt_raiseContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1524, PostgreSQLParserRULE_stmt_raise)
	p.SetState(10393)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 706, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(10367)
			p.Match(PostgreSQLParserRAISE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(10368)
			p.Opt_stmt_raise_level()
		}
		{
			p.SetState(10369)
			p.Sconst()
		}
		{
			p.SetState(10370)
			p.Opt_raise_list()
		}
		{
			p.SetState(10371)
			p.Opt_raise_using()
		}
		{
			p.SetState(10372)
			p.Match(PostgreSQLParserSEMI)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(10374)
			p.Match(PostgreSQLParserRAISE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(10375)
			p.Opt_stmt_raise_level()
		}
		{
			p.SetState(10376)
			p.Identifier()
		}
		{
			p.SetState(10377)
			p.Opt_raise_using()
		}
		{
			p.SetState(10378)
			p.Match(PostgreSQLParserSEMI)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 3:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(10380)
			p.Match(PostgreSQLParserRAISE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(10381)
			p.Opt_stmt_raise_level()
		}
		{
			p.SetState(10382)
			p.Match(PostgreSQLParserSQLSTATE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(10383)
			p.Sconst()
		}
		{
			p.SetState(10384)
			p.Opt_raise_using()
		}
		{
			p.SetState(10385)
			p.Match(PostgreSQLParserSEMI)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 4:
		p.EnterOuterAlt(localctx, 4)
		{
			p.SetState(10387)
			p.Match(PostgreSQLParserRAISE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(10388)
			p.Opt_stmt_raise_level()
		}
		{
			p.SetState(10389)
			p.Opt_raise_using()
		}
		{
			p.SetState(10390)
			p.Match(PostgreSQLParserSEMI)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 5:
		p.EnterOuterAlt(localctx, 5)
		{
			p.SetState(10392)
			p.Match(PostgreSQLParserRAISE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case antlr.ATNInvalidAltNumber:
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IOpt_stmt_raise_levelContext is an interface to support dynamic dispatch.
type IOpt_stmt_raise_levelContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	DEBUG() antlr.TerminalNode
	LOG() antlr.TerminalNode
	INFO() antlr.TerminalNode
	NOTICE() antlr.TerminalNode
	WARNING() antlr.TerminalNode
	EXCEPTION() antlr.TerminalNode

	// IsOpt_stmt_raise_levelContext differentiates from other interfaces.
	IsOpt_stmt_raise_levelContext()
}

type Opt_stmt_raise_levelContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyOpt_stmt_raise_levelContext() *Opt_stmt_raise_levelContext {
	var p = new(Opt_stmt_raise_levelContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opt_stmt_raise_level
	return p
}

func InitEmptyOpt_stmt_raise_levelContext(p *Opt_stmt_raise_levelContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opt_stmt_raise_level
}

func (*Opt_stmt_raise_levelContext) IsOpt_stmt_raise_levelContext() {}

func NewOpt_stmt_raise_levelContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_stmt_raise_levelContext {
	var p = new(Opt_stmt_raise_levelContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_opt_stmt_raise_level

	return p
}

func (s *Opt_stmt_raise_levelContext) GetParser() antlr.Parser { return s.parser }

func (s *Opt_stmt_raise_levelContext) DEBUG() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserDEBUG, 0)
}

func (s *Opt_stmt_raise_levelContext) LOG() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserLOG, 0)
}

func (s *Opt_stmt_raise_levelContext) INFO() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserINFO, 0)
}

func (s *Opt_stmt_raise_levelContext) NOTICE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserNOTICE, 0)
}

func (s *Opt_stmt_raise_levelContext) WARNING() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserWARNING, 0)
}

func (s *Opt_stmt_raise_levelContext) EXCEPTION() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserEXCEPTION, 0)
}

func (s *Opt_stmt_raise_levelContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Opt_stmt_raise_levelContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Opt_stmt_raise_levelContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterOpt_stmt_raise_level(s)
	}
}

func (s *Opt_stmt_raise_levelContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitOpt_stmt_raise_level(s)
	}
}

func (s *Opt_stmt_raise_levelContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitOpt_stmt_raise_level(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Opt_stmt_raise_level() (localctx IOpt_stmt_raise_levelContext) {
	localctx = NewOpt_stmt_raise_levelContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1526, PostgreSQLParserRULE_opt_stmt_raise_level)
	p.SetState(10403)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 707, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)

	case 2:
		p.EnterOuterAlt(localctx, 2)

	case 3:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(10397)
			p.Match(PostgreSQLParserDEBUG)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 4:
		p.EnterOuterAlt(localctx, 4)
		{
			p.SetState(10398)
			p.Match(PostgreSQLParserLOG)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 5:
		p.EnterOuterAlt(localctx, 5)
		{
			p.SetState(10399)
			p.Match(PostgreSQLParserINFO)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 6:
		p.EnterOuterAlt(localctx, 6)
		{
			p.SetState(10400)
			p.Match(PostgreSQLParserNOTICE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 7:
		p.EnterOuterAlt(localctx, 7)
		{
			p.SetState(10401)
			p.Match(PostgreSQLParserWARNING)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 8:
		p.EnterOuterAlt(localctx, 8)
		{
			p.SetState(10402)
			p.Match(PostgreSQLParserEXCEPTION)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case antlr.ATNInvalidAltNumber:
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IOpt_raise_listContext is an interface to support dynamic dispatch.
type IOpt_raise_listContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	AllCOMMA() []antlr.TerminalNode
	COMMA(i int) antlr.TerminalNode
	AllA_expr() []IA_exprContext
	A_expr(i int) IA_exprContext

	// IsOpt_raise_listContext differentiates from other interfaces.
	IsOpt_raise_listContext()
}

type Opt_raise_listContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyOpt_raise_listContext() *Opt_raise_listContext {
	var p = new(Opt_raise_listContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opt_raise_list
	return p
}

func InitEmptyOpt_raise_listContext(p *Opt_raise_listContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opt_raise_list
}

func (*Opt_raise_listContext) IsOpt_raise_listContext() {}

func NewOpt_raise_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_raise_listContext {
	var p = new(Opt_raise_listContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_opt_raise_list

	return p
}

func (s *Opt_raise_listContext) GetParser() antlr.Parser { return s.parser }

func (s *Opt_raise_listContext) AllCOMMA() []antlr.TerminalNode {
	return s.GetTokens(PostgreSQLParserCOMMA)
}

func (s *Opt_raise_listContext) COMMA(i int) antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCOMMA, i)
}

func (s *Opt_raise_listContext) AllA_expr() []IA_exprContext {
	children := s.GetChildren()
	len := 0
	for _, ctx := range children {
		if _, ok := ctx.(IA_exprContext); ok {
			len++
		}
	}

	tst := make([]IA_exprContext, len)
	i := 0
	for _, ctx := range children {
		if t, ok := ctx.(IA_exprContext); ok {
			tst[i] = t.(IA_exprContext)
			i++
		}
	}

	return tst
}

func (s *Opt_raise_listContext) A_expr(i int) IA_exprContext {
	var t antlr.RuleContext
	j := 0
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IA_exprContext); ok {
			if j == i {
				t = ctx.(antlr.RuleContext)
				break
			}
			j++
		}
	}

	if t == nil {
		return nil
	}

	return t.(IA_exprContext)
}

func (s *Opt_raise_listContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Opt_raise_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Opt_raise_listContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterOpt_raise_list(s)
	}
}

func (s *Opt_raise_listContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitOpt_raise_list(s)
	}
}

func (s *Opt_raise_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitOpt_raise_list(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Opt_raise_list() (localctx IOpt_raise_listContext) {
	localctx = NewOpt_raise_listContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1528, PostgreSQLParserRULE_opt_raise_list)
	var _la int

	p.SetState(10412)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetTokenStream().LA(1) {
	case PostgreSQLParserSEMI, PostgreSQLParserUSING:
		p.EnterOuterAlt(localctx, 1)

	case PostgreSQLParserCOMMA:
		p.EnterOuterAlt(localctx, 2)
		p.SetState(10408)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}
		_la = p.GetTokenStream().LA(1)

		for ok := true; ok; ok = _la == PostgreSQLParserCOMMA {
			{
				p.SetState(10406)
				p.Match(PostgreSQLParserCOMMA)
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}
			{
				p.SetState(10407)
				p.A_expr()
			}

			p.SetState(10410)
			p.GetErrorHandler().Sync(p)
			if p.HasError() {
				goto errorExit
			}
			_la = p.GetTokenStream().LA(1)
		}

	default:
		p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IOpt_raise_usingContext is an interface to support dynamic dispatch.
type IOpt_raise_usingContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	USING() antlr.TerminalNode
	Opt_raise_using_elem_list() IOpt_raise_using_elem_listContext

	// IsOpt_raise_usingContext differentiates from other interfaces.
	IsOpt_raise_usingContext()
}

type Opt_raise_usingContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyOpt_raise_usingContext() *Opt_raise_usingContext {
	var p = new(Opt_raise_usingContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opt_raise_using
	return p
}

func InitEmptyOpt_raise_usingContext(p *Opt_raise_usingContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opt_raise_using
}

func (*Opt_raise_usingContext) IsOpt_raise_usingContext() {}

func NewOpt_raise_usingContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_raise_usingContext {
	var p = new(Opt_raise_usingContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_opt_raise_using

	return p
}

func (s *Opt_raise_usingContext) GetParser() antlr.Parser { return s.parser }

func (s *Opt_raise_usingContext) USING() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserUSING, 0)
}

func (s *Opt_raise_usingContext) Opt_raise_using_elem_list() IOpt_raise_using_elem_listContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOpt_raise_using_elem_listContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOpt_raise_using_elem_listContext)
}

func (s *Opt_raise_usingContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Opt_raise_usingContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Opt_raise_usingContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterOpt_raise_using(s)
	}
}

func (s *Opt_raise_usingContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitOpt_raise_using(s)
	}
}

func (s *Opt_raise_usingContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitOpt_raise_using(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Opt_raise_using() (localctx IOpt_raise_usingContext) {
	localctx = NewOpt_raise_usingContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1530, PostgreSQLParserRULE_opt_raise_using)
	p.SetState(10417)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetTokenStream().LA(1) {
	case PostgreSQLParserSEMI:
		p.EnterOuterAlt(localctx, 1)

	case PostgreSQLParserUSING:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(10415)
			p.Match(PostgreSQLParserUSING)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(10416)
			p.Opt_raise_using_elem_list()
		}

	default:
		p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IOpt_raise_using_elemContext is an interface to support dynamic dispatch.
type IOpt_raise_using_elemContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Identifier() IIdentifierContext
	EQUAL() antlr.TerminalNode
	A_expr() IA_exprContext

	// IsOpt_raise_using_elemContext differentiates from other interfaces.
	IsOpt_raise_using_elemContext()
}

type Opt_raise_using_elemContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyOpt_raise_using_elemContext() *Opt_raise_using_elemContext {
	var p = new(Opt_raise_using_elemContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opt_raise_using_elem
	return p
}

func InitEmptyOpt_raise_using_elemContext(p *Opt_raise_using_elemContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opt_raise_using_elem
}

func (*Opt_raise_using_elemContext) IsOpt_raise_using_elemContext() {}

func NewOpt_raise_using_elemContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_raise_using_elemContext {
	var p = new(Opt_raise_using_elemContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_opt_raise_using_elem

	return p
}

func (s *Opt_raise_using_elemContext) GetParser() antlr.Parser { return s.parser }

func (s *Opt_raise_using_elemContext) Identifier() IIdentifierContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IIdentifierContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IIdentifierContext)
}

func (s *Opt_raise_using_elemContext) EQUAL() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserEQUAL, 0)
}

func (s *Opt_raise_using_elemContext) A_expr() IA_exprContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IA_exprContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IA_exprContext)
}

func (s *Opt_raise_using_elemContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Opt_raise_using_elemContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Opt_raise_using_elemContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterOpt_raise_using_elem(s)
	}
}

func (s *Opt_raise_using_elemContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitOpt_raise_using_elem(s)
	}
}

func (s *Opt_raise_using_elemContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitOpt_raise_using_elem(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Opt_raise_using_elem() (localctx IOpt_raise_using_elemContext) {
	localctx = NewOpt_raise_using_elemContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1532, PostgreSQLParserRULE_opt_raise_using_elem)
	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(10419)
		p.Identifier()
	}
	{
		p.SetState(10420)
		p.Match(PostgreSQLParserEQUAL)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(10421)
		p.A_expr()
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IOpt_raise_using_elem_listContext is an interface to support dynamic dispatch.
type IOpt_raise_using_elem_listContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	AllOpt_raise_using_elem() []IOpt_raise_using_elemContext
	Opt_raise_using_elem(i int) IOpt_raise_using_elemContext
	AllCOMMA() []antlr.TerminalNode
	COMMA(i int) antlr.TerminalNode

	// IsOpt_raise_using_elem_listContext differentiates from other interfaces.
	IsOpt_raise_using_elem_listContext()
}

type Opt_raise_using_elem_listContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyOpt_raise_using_elem_listContext() *Opt_raise_using_elem_listContext {
	var p = new(Opt_raise_using_elem_listContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opt_raise_using_elem_list
	return p
}

func InitEmptyOpt_raise_using_elem_listContext(p *Opt_raise_using_elem_listContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opt_raise_using_elem_list
}

func (*Opt_raise_using_elem_listContext) IsOpt_raise_using_elem_listContext() {}

func NewOpt_raise_using_elem_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_raise_using_elem_listContext {
	var p = new(Opt_raise_using_elem_listContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_opt_raise_using_elem_list

	return p
}

func (s *Opt_raise_using_elem_listContext) GetParser() antlr.Parser { return s.parser }

func (s *Opt_raise_using_elem_listContext) AllOpt_raise_using_elem() []IOpt_raise_using_elemContext {
	children := s.GetChildren()
	len := 0
	for _, ctx := range children {
		if _, ok := ctx.(IOpt_raise_using_elemContext); ok {
			len++
		}
	}

	tst := make([]IOpt_raise_using_elemContext, len)
	i := 0
	for _, ctx := range children {
		if t, ok := ctx.(IOpt_raise_using_elemContext); ok {
			tst[i] = t.(IOpt_raise_using_elemContext)
			i++
		}
	}

	return tst
}

func (s *Opt_raise_using_elem_listContext) Opt_raise_using_elem(i int) IOpt_raise_using_elemContext {
	var t antlr.RuleContext
	j := 0
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOpt_raise_using_elemContext); ok {
			if j == i {
				t = ctx.(antlr.RuleContext)
				break
			}
			j++
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOpt_raise_using_elemContext)
}

func (s *Opt_raise_using_elem_listContext) AllCOMMA() []antlr.TerminalNode {
	return s.GetTokens(PostgreSQLParserCOMMA)
}

func (s *Opt_raise_using_elem_listContext) COMMA(i int) antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCOMMA, i)
}

func (s *Opt_raise_using_elem_listContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Opt_raise_using_elem_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Opt_raise_using_elem_listContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterOpt_raise_using_elem_list(s)
	}
}

func (s *Opt_raise_using_elem_listContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitOpt_raise_using_elem_list(s)
	}
}

func (s *Opt_raise_using_elem_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitOpt_raise_using_elem_list(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Opt_raise_using_elem_list() (localctx IOpt_raise_using_elem_listContext) {
	localctx = NewOpt_raise_using_elem_listContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1534, PostgreSQLParserRULE_opt_raise_using_elem_list)
	var _la int

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(10423)
		p.Opt_raise_using_elem()
	}
	p.SetState(10428)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}
	_la = p.GetTokenStream().LA(1)

	for _la == PostgreSQLParserCOMMA {
		{
			p.SetState(10424)
			p.Match(PostgreSQLParserCOMMA)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(10425)
			p.Opt_raise_using_elem()
		}

		p.SetState(10430)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}
		_la = p.GetTokenStream().LA(1)
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IStmt_assertContext is an interface to support dynamic dispatch.
type IStmt_assertContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	ASSERT() antlr.TerminalNode
	Sql_expression() ISql_expressionContext
	Opt_stmt_assert_message() IOpt_stmt_assert_messageContext
	SEMI() antlr.TerminalNode

	// IsStmt_assertContext differentiates from other interfaces.
	IsStmt_assertContext()
}

type Stmt_assertContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyStmt_assertContext() *Stmt_assertContext {
	var p = new(Stmt_assertContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_stmt_assert
	return p
}

func InitEmptyStmt_assertContext(p *Stmt_assertContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_stmt_assert
}

func (*Stmt_assertContext) IsStmt_assertContext() {}

func NewStmt_assertContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Stmt_assertContext {
	var p = new(Stmt_assertContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_stmt_assert

	return p
}

func (s *Stmt_assertContext) GetParser() antlr.Parser { return s.parser }

func (s *Stmt_assertContext) ASSERT() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserASSERT, 0)
}

func (s *Stmt_assertContext) Sql_expression() ISql_expressionContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ISql_expressionContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ISql_expressionContext)
}

func (s *Stmt_assertContext) Opt_stmt_assert_message() IOpt_stmt_assert_messageContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOpt_stmt_assert_messageContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOpt_stmt_assert_messageContext)
}

func (s *Stmt_assertContext) SEMI() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserSEMI, 0)
}

func (s *Stmt_assertContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Stmt_assertContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Stmt_assertContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterStmt_assert(s)
	}
}

func (s *Stmt_assertContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitStmt_assert(s)
	}
}

func (s *Stmt_assertContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitStmt_assert(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Stmt_assert() (localctx IStmt_assertContext) {
	localctx = NewStmt_assertContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1536, PostgreSQLParserRULE_stmt_assert)
	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(10431)
		p.Match(PostgreSQLParserASSERT)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(10432)
		p.Sql_expression()
	}
	{
		p.SetState(10433)
		p.Opt_stmt_assert_message()
	}
	{
		p.SetState(10434)
		p.Match(PostgreSQLParserSEMI)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IOpt_stmt_assert_messageContext is an interface to support dynamic dispatch.
type IOpt_stmt_assert_messageContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	COMMA() antlr.TerminalNode
	Sql_expression() ISql_expressionContext

	// IsOpt_stmt_assert_messageContext differentiates from other interfaces.
	IsOpt_stmt_assert_messageContext()
}

type Opt_stmt_assert_messageContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyOpt_stmt_assert_messageContext() *Opt_stmt_assert_messageContext {
	var p = new(Opt_stmt_assert_messageContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opt_stmt_assert_message
	return p
}

func InitEmptyOpt_stmt_assert_messageContext(p *Opt_stmt_assert_messageContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opt_stmt_assert_message
}

func (*Opt_stmt_assert_messageContext) IsOpt_stmt_assert_messageContext() {}

func NewOpt_stmt_assert_messageContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_stmt_assert_messageContext {
	var p = new(Opt_stmt_assert_messageContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_opt_stmt_assert_message

	return p
}

func (s *Opt_stmt_assert_messageContext) GetParser() antlr.Parser { return s.parser }

func (s *Opt_stmt_assert_messageContext) COMMA() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCOMMA, 0)
}

func (s *Opt_stmt_assert_messageContext) Sql_expression() ISql_expressionContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ISql_expressionContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ISql_expressionContext)
}

func (s *Opt_stmt_assert_messageContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Opt_stmt_assert_messageContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Opt_stmt_assert_messageContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterOpt_stmt_assert_message(s)
	}
}

func (s *Opt_stmt_assert_messageContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitOpt_stmt_assert_message(s)
	}
}

func (s *Opt_stmt_assert_messageContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitOpt_stmt_assert_message(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Opt_stmt_assert_message() (localctx IOpt_stmt_assert_messageContext) {
	localctx = NewOpt_stmt_assert_messageContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1538, PostgreSQLParserRULE_opt_stmt_assert_message)
	p.SetState(10439)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetTokenStream().LA(1) {
	case PostgreSQLParserSEMI:
		p.EnterOuterAlt(localctx, 1)

	case PostgreSQLParserCOMMA:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(10437)
			p.Match(PostgreSQLParserCOMMA)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(10438)
			p.Sql_expression()
		}

	default:
		p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// ILoop_bodyContext is an interface to support dynamic dispatch.
type ILoop_bodyContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	AllLOOP() []antlr.TerminalNode
	LOOP(i int) antlr.TerminalNode
	Proc_sect() IProc_sectContext
	END_P() antlr.TerminalNode
	Opt_label() IOpt_labelContext
	SEMI() antlr.TerminalNode

	// IsLoop_bodyContext differentiates from other interfaces.
	IsLoop_bodyContext()
}

type Loop_bodyContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyLoop_bodyContext() *Loop_bodyContext {
	var p = new(Loop_bodyContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_loop_body
	return p
}

func InitEmptyLoop_bodyContext(p *Loop_bodyContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_loop_body
}

func (*Loop_bodyContext) IsLoop_bodyContext() {}

func NewLoop_bodyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Loop_bodyContext {
	var p = new(Loop_bodyContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_loop_body

	return p
}

func (s *Loop_bodyContext) GetParser() antlr.Parser { return s.parser }

func (s *Loop_bodyContext) AllLOOP() []antlr.TerminalNode {
	return s.GetTokens(PostgreSQLParserLOOP)
}

func (s *Loop_bodyContext) LOOP(i int) antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserLOOP, i)
}

func (s *Loop_bodyContext) Proc_sect() IProc_sectContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IProc_sectContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IProc_sectContext)
}

func (s *Loop_bodyContext) END_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserEND_P, 0)
}

func (s *Loop_bodyContext) Opt_label() IOpt_labelContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOpt_labelContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOpt_labelContext)
}

func (s *Loop_bodyContext) SEMI() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserSEMI, 0)
}

func (s *Loop_bodyContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Loop_bodyContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Loop_bodyContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterLoop_body(s)
	}
}

func (s *Loop_bodyContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitLoop_body(s)
	}
}

func (s *Loop_bodyContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitLoop_body(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Loop_body() (localctx ILoop_bodyContext) {
	localctx = NewLoop_bodyContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1540, PostgreSQLParserRULE_loop_body)
	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(10441)
		p.Match(PostgreSQLParserLOOP)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(10442)
		p.Proc_sect()
	}
	{
		p.SetState(10443)
		p.Match(PostgreSQLParserEND_P)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(10444)
		p.Match(PostgreSQLParserLOOP)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(10445)
		p.Opt_label()
	}
	{
		p.SetState(10446)
		p.Match(PostgreSQLParserSEMI)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IStmt_execsqlContext is an interface to support dynamic dispatch.
type IStmt_execsqlContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Make_execsql_stmt() IMake_execsql_stmtContext
	SEMI() antlr.TerminalNode

	// IsStmt_execsqlContext differentiates from other interfaces.
	IsStmt_execsqlContext()
}

type Stmt_execsqlContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyStmt_execsqlContext() *Stmt_execsqlContext {
	var p = new(Stmt_execsqlContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_stmt_execsql
	return p
}

func InitEmptyStmt_execsqlContext(p *Stmt_execsqlContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_stmt_execsql
}

func (*Stmt_execsqlContext) IsStmt_execsqlContext() {}

func NewStmt_execsqlContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Stmt_execsqlContext {
	var p = new(Stmt_execsqlContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_stmt_execsql

	return p
}

func (s *Stmt_execsqlContext) GetParser() antlr.Parser { return s.parser }

func (s *Stmt_execsqlContext) Make_execsql_stmt() IMake_execsql_stmtContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IMake_execsql_stmtContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IMake_execsql_stmtContext)
}

func (s *Stmt_execsqlContext) SEMI() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserSEMI, 0)
}

func (s *Stmt_execsqlContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Stmt_execsqlContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Stmt_execsqlContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterStmt_execsql(s)
	}
}

func (s *Stmt_execsqlContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitStmt_execsql(s)
	}
}

func (s *Stmt_execsqlContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitStmt_execsql(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Stmt_execsql() (localctx IStmt_execsqlContext) {
	localctx = NewStmt_execsqlContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1542, PostgreSQLParserRULE_stmt_execsql)
	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(10448)
		p.Make_execsql_stmt()
	}
	{
		p.SetState(10449)
		p.Match(PostgreSQLParserSEMI)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IStmt_dynexecuteContext is an interface to support dynamic dispatch.
type IStmt_dynexecuteContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	EXECUTE() antlr.TerminalNode
	A_expr() IA_exprContext
	SEMI() antlr.TerminalNode
	Opt_execute_into() IOpt_execute_intoContext
	Opt_execute_using() IOpt_execute_usingContext

	// IsStmt_dynexecuteContext differentiates from other interfaces.
	IsStmt_dynexecuteContext()
}

type Stmt_dynexecuteContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyStmt_dynexecuteContext() *Stmt_dynexecuteContext {
	var p = new(Stmt_dynexecuteContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_stmt_dynexecute
	return p
}

func InitEmptyStmt_dynexecuteContext(p *Stmt_dynexecuteContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_stmt_dynexecute
}

func (*Stmt_dynexecuteContext) IsStmt_dynexecuteContext() {}

func NewStmt_dynexecuteContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Stmt_dynexecuteContext {
	var p = new(Stmt_dynexecuteContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_stmt_dynexecute

	return p
}

func (s *Stmt_dynexecuteContext) GetParser() antlr.Parser { return s.parser }

func (s *Stmt_dynexecuteContext) EXECUTE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserEXECUTE, 0)
}

func (s *Stmt_dynexecuteContext) A_expr() IA_exprContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IA_exprContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IA_exprContext)
}

func (s *Stmt_dynexecuteContext) SEMI() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserSEMI, 0)
}

func (s *Stmt_dynexecuteContext) Opt_execute_into() IOpt_execute_intoContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOpt_execute_intoContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOpt_execute_intoContext)
}

func (s *Stmt_dynexecuteContext) Opt_execute_using() IOpt_execute_usingContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOpt_execute_usingContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOpt_execute_usingContext)
}

func (s *Stmt_dynexecuteContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Stmt_dynexecuteContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Stmt_dynexecuteContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterStmt_dynexecute(s)
	}
}

func (s *Stmt_dynexecuteContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitStmt_dynexecute(s)
	}
}

func (s *Stmt_dynexecuteContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitStmt_dynexecute(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Stmt_dynexecute() (localctx IStmt_dynexecuteContext) {
	localctx = NewStmt_dynexecuteContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1544, PostgreSQLParserRULE_stmt_dynexecute)
	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(10451)
		p.Match(PostgreSQLParserEXECUTE)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(10452)
		p.A_expr()
	}
	p.SetState(10460)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 713, p.GetParserRuleContext()) {
	case 1:
		{
			p.SetState(10453)
			p.Opt_execute_into()
		}
		{
			p.SetState(10454)
			p.Opt_execute_using()
		}

	case 2:
		{
			p.SetState(10456)
			p.Opt_execute_using()
		}
		{
			p.SetState(10457)
			p.Opt_execute_into()
		}

	case 3:

	case antlr.ATNInvalidAltNumber:
		goto errorExit
	}
	{
		p.SetState(10462)
		p.Match(PostgreSQLParserSEMI)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IOpt_execute_usingContext is an interface to support dynamic dispatch.
type IOpt_execute_usingContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	USING() antlr.TerminalNode
	Opt_execute_using_list() IOpt_execute_using_listContext

	// IsOpt_execute_usingContext differentiates from other interfaces.
	IsOpt_execute_usingContext()
}

type Opt_execute_usingContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyOpt_execute_usingContext() *Opt_execute_usingContext {
	var p = new(Opt_execute_usingContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opt_execute_using
	return p
}

func InitEmptyOpt_execute_usingContext(p *Opt_execute_usingContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opt_execute_using
}

func (*Opt_execute_usingContext) IsOpt_execute_usingContext() {}

func NewOpt_execute_usingContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_execute_usingContext {
	var p = new(Opt_execute_usingContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_opt_execute_using

	return p
}

func (s *Opt_execute_usingContext) GetParser() antlr.Parser { return s.parser }

func (s *Opt_execute_usingContext) USING() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserUSING, 0)
}

func (s *Opt_execute_usingContext) Opt_execute_using_list() IOpt_execute_using_listContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOpt_execute_using_listContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOpt_execute_using_listContext)
}

func (s *Opt_execute_usingContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Opt_execute_usingContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Opt_execute_usingContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterOpt_execute_using(s)
	}
}

func (s *Opt_execute_usingContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitOpt_execute_using(s)
	}
}

func (s *Opt_execute_usingContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitOpt_execute_using(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Opt_execute_using() (localctx IOpt_execute_usingContext) {
	localctx = NewOpt_execute_usingContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1546, PostgreSQLParserRULE_opt_execute_using)
	p.SetState(10467)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetTokenStream().LA(1) {
	case PostgreSQLParserSEMI, PostgreSQLParserINTO:
		p.EnterOuterAlt(localctx, 1)

	case PostgreSQLParserUSING:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(10465)
			p.Match(PostgreSQLParserUSING)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(10466)
			p.Opt_execute_using_list()
		}

	default:
		p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IOpt_execute_using_listContext is an interface to support dynamic dispatch.
type IOpt_execute_using_listContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	AllA_expr() []IA_exprContext
	A_expr(i int) IA_exprContext
	AllCOMMA() []antlr.TerminalNode
	COMMA(i int) antlr.TerminalNode

	// IsOpt_execute_using_listContext differentiates from other interfaces.
	IsOpt_execute_using_listContext()
}

type Opt_execute_using_listContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyOpt_execute_using_listContext() *Opt_execute_using_listContext {
	var p = new(Opt_execute_using_listContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opt_execute_using_list
	return p
}

func InitEmptyOpt_execute_using_listContext(p *Opt_execute_using_listContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opt_execute_using_list
}

func (*Opt_execute_using_listContext) IsOpt_execute_using_listContext() {}

func NewOpt_execute_using_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_execute_using_listContext {
	var p = new(Opt_execute_using_listContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_opt_execute_using_list

	return p
}

func (s *Opt_execute_using_listContext) GetParser() antlr.Parser { return s.parser }

func (s *Opt_execute_using_listContext) AllA_expr() []IA_exprContext {
	children := s.GetChildren()
	len := 0
	for _, ctx := range children {
		if _, ok := ctx.(IA_exprContext); ok {
			len++
		}
	}

	tst := make([]IA_exprContext, len)
	i := 0
	for _, ctx := range children {
		if t, ok := ctx.(IA_exprContext); ok {
			tst[i] = t.(IA_exprContext)
			i++
		}
	}

	return tst
}

func (s *Opt_execute_using_listContext) A_expr(i int) IA_exprContext {
	var t antlr.RuleContext
	j := 0
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IA_exprContext); ok {
			if j == i {
				t = ctx.(antlr.RuleContext)
				break
			}
			j++
		}
	}

	if t == nil {
		return nil
	}

	return t.(IA_exprContext)
}

func (s *Opt_execute_using_listContext) AllCOMMA() []antlr.TerminalNode {
	return s.GetTokens(PostgreSQLParserCOMMA)
}

func (s *Opt_execute_using_listContext) COMMA(i int) antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCOMMA, i)
}

func (s *Opt_execute_using_listContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Opt_execute_using_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Opt_execute_using_listContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterOpt_execute_using_list(s)
	}
}

func (s *Opt_execute_using_listContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitOpt_execute_using_list(s)
	}
}

func (s *Opt_execute_using_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitOpt_execute_using_list(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Opt_execute_using_list() (localctx IOpt_execute_using_listContext) {
	localctx = NewOpt_execute_using_listContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1548, PostgreSQLParserRULE_opt_execute_using_list)
	var _la int

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(10469)
		p.A_expr()
	}
	p.SetState(10474)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}
	_la = p.GetTokenStream().LA(1)

	for _la == PostgreSQLParserCOMMA {
		{
			p.SetState(10470)
			p.Match(PostgreSQLParserCOMMA)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(10471)
			p.A_expr()
		}

		p.SetState(10476)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}
		_la = p.GetTokenStream().LA(1)
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IOpt_execute_intoContext is an interface to support dynamic dispatch.
type IOpt_execute_intoContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	INTO() antlr.TerminalNode
	Into_target() IInto_targetContext
	STRICT_P() antlr.TerminalNode

	// IsOpt_execute_intoContext differentiates from other interfaces.
	IsOpt_execute_intoContext()
}

type Opt_execute_intoContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyOpt_execute_intoContext() *Opt_execute_intoContext {
	var p = new(Opt_execute_intoContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opt_execute_into
	return p
}

func InitEmptyOpt_execute_intoContext(p *Opt_execute_intoContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opt_execute_into
}

func (*Opt_execute_intoContext) IsOpt_execute_intoContext() {}

func NewOpt_execute_intoContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_execute_intoContext {
	var p = new(Opt_execute_intoContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_opt_execute_into

	return p
}

func (s *Opt_execute_intoContext) GetParser() antlr.Parser { return s.parser }

func (s *Opt_execute_intoContext) INTO() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserINTO, 0)
}

func (s *Opt_execute_intoContext) Into_target() IInto_targetContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IInto_targetContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IInto_targetContext)
}

func (s *Opt_execute_intoContext) STRICT_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserSTRICT_P, 0)
}

func (s *Opt_execute_intoContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Opt_execute_intoContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Opt_execute_intoContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterOpt_execute_into(s)
	}
}

func (s *Opt_execute_intoContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitOpt_execute_into(s)
	}
}

func (s *Opt_execute_intoContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitOpt_execute_into(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Opt_execute_into() (localctx IOpt_execute_intoContext) {
	localctx = NewOpt_execute_intoContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1550, PostgreSQLParserRULE_opt_execute_into)
	p.SetState(10483)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetTokenStream().LA(1) {
	case PostgreSQLParserSEMI, PostgreSQLParserUSING:
		p.EnterOuterAlt(localctx, 1)

	case PostgreSQLParserINTO:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(10478)
			p.Match(PostgreSQLParserINTO)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		p.SetState(10480)
		p.GetErrorHandler().Sync(p)

		if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 716, p.GetParserRuleContext()) == 1 {
			{
				p.SetState(10479)
				p.Match(PostgreSQLParserSTRICT_P)
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}

		} else if p.HasError() { // JIM
			goto errorExit
		}
		{
			p.SetState(10482)
			p.Into_target()
		}

	default:
		p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IStmt_openContext is an interface to support dynamic dispatch.
type IStmt_openContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	OPEN() antlr.TerminalNode
	SEMI() antlr.TerminalNode
	Cursor_variable() ICursor_variableContext
	Opt_scroll_option() IOpt_scroll_optionContext
	FOR() antlr.TerminalNode
	Colid() IColidContext
	Selectstmt() ISelectstmtContext
	EXECUTE() antlr.TerminalNode
	Sql_expression() ISql_expressionContext
	Opt_open_using() IOpt_open_usingContext
	OPEN_PAREN() antlr.TerminalNode
	Opt_open_bound_list() IOpt_open_bound_listContext
	CLOSE_PAREN() antlr.TerminalNode

	// IsStmt_openContext differentiates from other interfaces.
	IsStmt_openContext()
}

type Stmt_openContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyStmt_openContext() *Stmt_openContext {
	var p = new(Stmt_openContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_stmt_open
	return p
}

func InitEmptyStmt_openContext(p *Stmt_openContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_stmt_open
}

func (*Stmt_openContext) IsStmt_openContext() {}

func NewStmt_openContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Stmt_openContext {
	var p = new(Stmt_openContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_stmt_open

	return p
}

func (s *Stmt_openContext) GetParser() antlr.Parser { return s.parser }

func (s *Stmt_openContext) OPEN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserOPEN, 0)
}

func (s *Stmt_openContext) SEMI() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserSEMI, 0)
}

func (s *Stmt_openContext) Cursor_variable() ICursor_variableContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ICursor_variableContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ICursor_variableContext)
}

func (s *Stmt_openContext) Opt_scroll_option() IOpt_scroll_optionContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOpt_scroll_optionContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOpt_scroll_optionContext)
}

func (s *Stmt_openContext) FOR() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserFOR, 0)
}

func (s *Stmt_openContext) Colid() IColidContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IColidContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IColidContext)
}

func (s *Stmt_openContext) Selectstmt() ISelectstmtContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ISelectstmtContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ISelectstmtContext)
}

func (s *Stmt_openContext) EXECUTE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserEXECUTE, 0)
}

func (s *Stmt_openContext) Sql_expression() ISql_expressionContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ISql_expressionContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ISql_expressionContext)
}

func (s *Stmt_openContext) Opt_open_using() IOpt_open_usingContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOpt_open_usingContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOpt_open_usingContext)
}

func (s *Stmt_openContext) OPEN_PAREN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserOPEN_PAREN, 0)
}

func (s *Stmt_openContext) Opt_open_bound_list() IOpt_open_bound_listContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOpt_open_bound_listContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOpt_open_bound_listContext)
}

func (s *Stmt_openContext) CLOSE_PAREN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCLOSE_PAREN, 0)
}

func (s *Stmt_openContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Stmt_openContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Stmt_openContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterStmt_open(s)
	}
}

func (s *Stmt_openContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitStmt_open(s)
	}
}

func (s *Stmt_openContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitStmt_open(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Stmt_open() (localctx IStmt_openContext) {
	localctx = NewStmt_openContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1552, PostgreSQLParserRULE_stmt_open)
	var _la int

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(10485)
		p.Match(PostgreSQLParserOPEN)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	p.SetState(10503)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 720, p.GetParserRuleContext()) {
	case 1:
		{
			p.SetState(10486)
			p.Cursor_variable()
		}
		{
			p.SetState(10487)
			p.Opt_scroll_option()
		}
		{
			p.SetState(10488)
			p.Match(PostgreSQLParserFOR)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		p.SetState(10494)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}

		switch p.GetTokenStream().LA(1) {
		case PostgreSQLParserOPEN_PAREN, PostgreSQLParserSELECT, PostgreSQLParserTABLE, PostgreSQLParserWITH, PostgreSQLParserVALUES:
			{
				p.SetState(10489)
				p.Selectstmt()
			}

		case PostgreSQLParserEXECUTE:
			{
				p.SetState(10490)
				p.Match(PostgreSQLParserEXECUTE)
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}
			{
				p.SetState(10491)
				p.Sql_expression()
			}
			{
				p.SetState(10492)
				p.Opt_open_using()
			}

		default:
			p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
			goto errorExit
		}

	case 2:
		{
			p.SetState(10496)
			p.Colid()
		}
		p.SetState(10501)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}
		_la = p.GetTokenStream().LA(1)

		if _la == PostgreSQLParserOPEN_PAREN {
			{
				p.SetState(10497)
				p.Match(PostgreSQLParserOPEN_PAREN)
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}
			{
				p.SetState(10498)
				p.Opt_open_bound_list()
			}
			{
				p.SetState(10499)
				p.Match(PostgreSQLParserCLOSE_PAREN)
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}

		}

	case antlr.ATNInvalidAltNumber:
		goto errorExit
	}
	{
		p.SetState(10505)
		p.Match(PostgreSQLParserSEMI)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IOpt_open_bound_list_itemContext is an interface to support dynamic dispatch.
type IOpt_open_bound_list_itemContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Colid() IColidContext
	COLON_EQUALS() antlr.TerminalNode
	A_expr() IA_exprContext

	// IsOpt_open_bound_list_itemContext differentiates from other interfaces.
	IsOpt_open_bound_list_itemContext()
}

type Opt_open_bound_list_itemContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyOpt_open_bound_list_itemContext() *Opt_open_bound_list_itemContext {
	var p = new(Opt_open_bound_list_itemContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opt_open_bound_list_item
	return p
}

func InitEmptyOpt_open_bound_list_itemContext(p *Opt_open_bound_list_itemContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opt_open_bound_list_item
}

func (*Opt_open_bound_list_itemContext) IsOpt_open_bound_list_itemContext() {}

func NewOpt_open_bound_list_itemContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_open_bound_list_itemContext {
	var p = new(Opt_open_bound_list_itemContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_opt_open_bound_list_item

	return p
}

func (s *Opt_open_bound_list_itemContext) GetParser() antlr.Parser { return s.parser }

func (s *Opt_open_bound_list_itemContext) Colid() IColidContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IColidContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IColidContext)
}

func (s *Opt_open_bound_list_itemContext) COLON_EQUALS() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCOLON_EQUALS, 0)
}

func (s *Opt_open_bound_list_itemContext) A_expr() IA_exprContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IA_exprContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IA_exprContext)
}

func (s *Opt_open_bound_list_itemContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Opt_open_bound_list_itemContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Opt_open_bound_list_itemContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterOpt_open_bound_list_item(s)
	}
}

func (s *Opt_open_bound_list_itemContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitOpt_open_bound_list_item(s)
	}
}

func (s *Opt_open_bound_list_itemContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitOpt_open_bound_list_item(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Opt_open_bound_list_item() (localctx IOpt_open_bound_list_itemContext) {
	localctx = NewOpt_open_bound_list_itemContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1554, PostgreSQLParserRULE_opt_open_bound_list_item)
	p.SetState(10512)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 721, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(10507)
			p.Colid()
		}
		{
			p.SetState(10508)
			p.Match(PostgreSQLParserCOLON_EQUALS)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(10509)
			p.A_expr()
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(10511)
			p.A_expr()
		}

	case antlr.ATNInvalidAltNumber:
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IOpt_open_bound_listContext is an interface to support dynamic dispatch.
type IOpt_open_bound_listContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	AllOpt_open_bound_list_item() []IOpt_open_bound_list_itemContext
	Opt_open_bound_list_item(i int) IOpt_open_bound_list_itemContext
	AllCOMMA() []antlr.TerminalNode
	COMMA(i int) antlr.TerminalNode

	// IsOpt_open_bound_listContext differentiates from other interfaces.
	IsOpt_open_bound_listContext()
}

type Opt_open_bound_listContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyOpt_open_bound_listContext() *Opt_open_bound_listContext {
	var p = new(Opt_open_bound_listContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opt_open_bound_list
	return p
}

func InitEmptyOpt_open_bound_listContext(p *Opt_open_bound_listContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opt_open_bound_list
}

func (*Opt_open_bound_listContext) IsOpt_open_bound_listContext() {}

func NewOpt_open_bound_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_open_bound_listContext {
	var p = new(Opt_open_bound_listContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_opt_open_bound_list

	return p
}

func (s *Opt_open_bound_listContext) GetParser() antlr.Parser { return s.parser }

func (s *Opt_open_bound_listContext) AllOpt_open_bound_list_item() []IOpt_open_bound_list_itemContext {
	children := s.GetChildren()
	len := 0
	for _, ctx := range children {
		if _, ok := ctx.(IOpt_open_bound_list_itemContext); ok {
			len++
		}
	}

	tst := make([]IOpt_open_bound_list_itemContext, len)
	i := 0
	for _, ctx := range children {
		if t, ok := ctx.(IOpt_open_bound_list_itemContext); ok {
			tst[i] = t.(IOpt_open_bound_list_itemContext)
			i++
		}
	}

	return tst
}

func (s *Opt_open_bound_listContext) Opt_open_bound_list_item(i int) IOpt_open_bound_list_itemContext {
	var t antlr.RuleContext
	j := 0
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOpt_open_bound_list_itemContext); ok {
			if j == i {
				t = ctx.(antlr.RuleContext)
				break
			}
			j++
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOpt_open_bound_list_itemContext)
}

func (s *Opt_open_bound_listContext) AllCOMMA() []antlr.TerminalNode {
	return s.GetTokens(PostgreSQLParserCOMMA)
}

func (s *Opt_open_bound_listContext) COMMA(i int) antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCOMMA, i)
}

func (s *Opt_open_bound_listContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Opt_open_bound_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Opt_open_bound_listContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterOpt_open_bound_list(s)
	}
}

func (s *Opt_open_bound_listContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitOpt_open_bound_list(s)
	}
}

func (s *Opt_open_bound_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitOpt_open_bound_list(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Opt_open_bound_list() (localctx IOpt_open_bound_listContext) {
	localctx = NewOpt_open_bound_listContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1556, PostgreSQLParserRULE_opt_open_bound_list)
	var _la int

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(10514)
		p.Opt_open_bound_list_item()
	}
	p.SetState(10519)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}
	_la = p.GetTokenStream().LA(1)

	for _la == PostgreSQLParserCOMMA {
		{
			p.SetState(10515)
			p.Match(PostgreSQLParserCOMMA)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(10516)
			p.Opt_open_bound_list_item()
		}

		p.SetState(10521)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}
		_la = p.GetTokenStream().LA(1)
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IOpt_open_usingContext is an interface to support dynamic dispatch.
type IOpt_open_usingContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	USING() antlr.TerminalNode
	Expr_list() IExpr_listContext

	// IsOpt_open_usingContext differentiates from other interfaces.
	IsOpt_open_usingContext()
}

type Opt_open_usingContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyOpt_open_usingContext() *Opt_open_usingContext {
	var p = new(Opt_open_usingContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opt_open_using
	return p
}

func InitEmptyOpt_open_usingContext(p *Opt_open_usingContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opt_open_using
}

func (*Opt_open_usingContext) IsOpt_open_usingContext() {}

func NewOpt_open_usingContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_open_usingContext {
	var p = new(Opt_open_usingContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_opt_open_using

	return p
}

func (s *Opt_open_usingContext) GetParser() antlr.Parser { return s.parser }

func (s *Opt_open_usingContext) USING() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserUSING, 0)
}

func (s *Opt_open_usingContext) Expr_list() IExpr_listContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IExpr_listContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IExpr_listContext)
}

func (s *Opt_open_usingContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Opt_open_usingContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Opt_open_usingContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterOpt_open_using(s)
	}
}

func (s *Opt_open_usingContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitOpt_open_using(s)
	}
}

func (s *Opt_open_usingContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitOpt_open_using(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Opt_open_using() (localctx IOpt_open_usingContext) {
	localctx = NewOpt_open_usingContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1558, PostgreSQLParserRULE_opt_open_using)
	p.SetState(10525)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetTokenStream().LA(1) {
	case PostgreSQLParserSEMI:
		p.EnterOuterAlt(localctx, 1)

	case PostgreSQLParserUSING:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(10523)
			p.Match(PostgreSQLParserUSING)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(10524)
			p.Expr_list()
		}

	default:
		p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IOpt_scroll_optionContext is an interface to support dynamic dispatch.
type IOpt_scroll_optionContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Opt_scroll_option_no() IOpt_scroll_option_noContext
	SCROLL() antlr.TerminalNode

	// IsOpt_scroll_optionContext differentiates from other interfaces.
	IsOpt_scroll_optionContext()
}

type Opt_scroll_optionContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyOpt_scroll_optionContext() *Opt_scroll_optionContext {
	var p = new(Opt_scroll_optionContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opt_scroll_option
	return p
}

func InitEmptyOpt_scroll_optionContext(p *Opt_scroll_optionContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opt_scroll_option
}

func (*Opt_scroll_optionContext) IsOpt_scroll_optionContext() {}

func NewOpt_scroll_optionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_scroll_optionContext {
	var p = new(Opt_scroll_optionContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_opt_scroll_option

	return p
}

func (s *Opt_scroll_optionContext) GetParser() antlr.Parser { return s.parser }

func (s *Opt_scroll_optionContext) Opt_scroll_option_no() IOpt_scroll_option_noContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOpt_scroll_option_noContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOpt_scroll_option_noContext)
}

func (s *Opt_scroll_optionContext) SCROLL() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserSCROLL, 0)
}

func (s *Opt_scroll_optionContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Opt_scroll_optionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Opt_scroll_optionContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterOpt_scroll_option(s)
	}
}

func (s *Opt_scroll_optionContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitOpt_scroll_option(s)
	}
}

func (s *Opt_scroll_optionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitOpt_scroll_option(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Opt_scroll_option() (localctx IOpt_scroll_optionContext) {
	localctx = NewOpt_scroll_optionContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1560, PostgreSQLParserRULE_opt_scroll_option)
	p.SetState(10531)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetTokenStream().LA(1) {
	case PostgreSQLParserFOR:
		p.EnterOuterAlt(localctx, 1)

	case PostgreSQLParserNO, PostgreSQLParserSCROLL:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(10528)
			p.Opt_scroll_option_no()
		}
		{
			p.SetState(10529)
			p.Match(PostgreSQLParserSCROLL)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	default:
		p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IOpt_scroll_option_noContext is an interface to support dynamic dispatch.
type IOpt_scroll_option_noContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	NO() antlr.TerminalNode

	// IsOpt_scroll_option_noContext differentiates from other interfaces.
	IsOpt_scroll_option_noContext()
}

type Opt_scroll_option_noContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyOpt_scroll_option_noContext() *Opt_scroll_option_noContext {
	var p = new(Opt_scroll_option_noContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opt_scroll_option_no
	return p
}

func InitEmptyOpt_scroll_option_noContext(p *Opt_scroll_option_noContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opt_scroll_option_no
}

func (*Opt_scroll_option_noContext) IsOpt_scroll_option_noContext() {}

func NewOpt_scroll_option_noContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_scroll_option_noContext {
	var p = new(Opt_scroll_option_noContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_opt_scroll_option_no

	return p
}

func (s *Opt_scroll_option_noContext) GetParser() antlr.Parser { return s.parser }

func (s *Opt_scroll_option_noContext) NO() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserNO, 0)
}

func (s *Opt_scroll_option_noContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Opt_scroll_option_noContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Opt_scroll_option_noContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterOpt_scroll_option_no(s)
	}
}

func (s *Opt_scroll_option_noContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitOpt_scroll_option_no(s)
	}
}

func (s *Opt_scroll_option_noContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitOpt_scroll_option_no(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Opt_scroll_option_no() (localctx IOpt_scroll_option_noContext) {
	localctx = NewOpt_scroll_option_noContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1562, PostgreSQLParserRULE_opt_scroll_option_no)
	p.SetState(10535)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetTokenStream().LA(1) {
	case PostgreSQLParserSCROLL:
		p.EnterOuterAlt(localctx, 1)

	case PostgreSQLParserNO:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(10534)
			p.Match(PostgreSQLParserNO)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	default:
		p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IStmt_fetchContext is an interface to support dynamic dispatch.
type IStmt_fetchContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetDirection returns the direction rule contexts.
	GetDirection() IOpt_fetch_directionContext

	// SetDirection sets the direction rule contexts.
	SetDirection(IOpt_fetch_directionContext)

	// Getter signatures
	FETCH() antlr.TerminalNode
	Opt_cursor_from() IOpt_cursor_fromContext
	Cursor_variable() ICursor_variableContext
	INTO() antlr.TerminalNode
	Into_target() IInto_targetContext
	SEMI() antlr.TerminalNode
	Opt_fetch_direction() IOpt_fetch_directionContext

	// IsStmt_fetchContext differentiates from other interfaces.
	IsStmt_fetchContext()
}

type Stmt_fetchContext struct {
	antlr.BaseParserRuleContext
	parser    antlr.Parser
	direction IOpt_fetch_directionContext
}

func NewEmptyStmt_fetchContext() *Stmt_fetchContext {
	var p = new(Stmt_fetchContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_stmt_fetch
	return p
}

func InitEmptyStmt_fetchContext(p *Stmt_fetchContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_stmt_fetch
}

func (*Stmt_fetchContext) IsStmt_fetchContext() {}

func NewStmt_fetchContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Stmt_fetchContext {
	var p = new(Stmt_fetchContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_stmt_fetch

	return p
}

func (s *Stmt_fetchContext) GetParser() antlr.Parser { return s.parser }

func (s *Stmt_fetchContext) GetDirection() IOpt_fetch_directionContext { return s.direction }

func (s *Stmt_fetchContext) SetDirection(v IOpt_fetch_directionContext) { s.direction = v }

func (s *Stmt_fetchContext) FETCH() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserFETCH, 0)
}

func (s *Stmt_fetchContext) Opt_cursor_from() IOpt_cursor_fromContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOpt_cursor_fromContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOpt_cursor_fromContext)
}

func (s *Stmt_fetchContext) Cursor_variable() ICursor_variableContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ICursor_variableContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ICursor_variableContext)
}

func (s *Stmt_fetchContext) INTO() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserINTO, 0)
}

func (s *Stmt_fetchContext) Into_target() IInto_targetContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IInto_targetContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IInto_targetContext)
}

func (s *Stmt_fetchContext) SEMI() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserSEMI, 0)
}

func (s *Stmt_fetchContext) Opt_fetch_direction() IOpt_fetch_directionContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOpt_fetch_directionContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOpt_fetch_directionContext)
}

func (s *Stmt_fetchContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Stmt_fetchContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Stmt_fetchContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterStmt_fetch(s)
	}
}

func (s *Stmt_fetchContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitStmt_fetch(s)
	}
}

func (s *Stmt_fetchContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitStmt_fetch(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Stmt_fetch() (localctx IStmt_fetchContext) {
	localctx = NewStmt_fetchContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1564, PostgreSQLParserRULE_stmt_fetch)
	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(10537)
		p.Match(PostgreSQLParserFETCH)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(10538)

		var _x = p.Opt_fetch_direction()

		localctx.(*Stmt_fetchContext).direction = _x
	}
	{
		p.SetState(10539)
		p.Opt_cursor_from()
	}
	{
		p.SetState(10540)
		p.Cursor_variable()
	}
	{
		p.SetState(10541)
		p.Match(PostgreSQLParserINTO)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(10542)
		p.Into_target()
	}
	{
		p.SetState(10543)
		p.Match(PostgreSQLParserSEMI)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IInto_targetContext is an interface to support dynamic dispatch.
type IInto_targetContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Expr_list() IExpr_listContext

	// IsInto_targetContext differentiates from other interfaces.
	IsInto_targetContext()
}

type Into_targetContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyInto_targetContext() *Into_targetContext {
	var p = new(Into_targetContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_into_target
	return p
}

func InitEmptyInto_targetContext(p *Into_targetContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_into_target
}

func (*Into_targetContext) IsInto_targetContext() {}

func NewInto_targetContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Into_targetContext {
	var p = new(Into_targetContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_into_target

	return p
}

func (s *Into_targetContext) GetParser() antlr.Parser { return s.parser }

func (s *Into_targetContext) Expr_list() IExpr_listContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IExpr_listContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IExpr_listContext)
}

func (s *Into_targetContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Into_targetContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Into_targetContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterInto_target(s)
	}
}

func (s *Into_targetContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitInto_target(s)
	}
}

func (s *Into_targetContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitInto_target(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Into_target() (localctx IInto_targetContext) {
	localctx = NewInto_targetContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1566, PostgreSQLParserRULE_into_target)
	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(10545)
		p.Expr_list()
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IOpt_cursor_fromContext is an interface to support dynamic dispatch.
type IOpt_cursor_fromContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	FROM() antlr.TerminalNode
	IN_P() antlr.TerminalNode

	// IsOpt_cursor_fromContext differentiates from other interfaces.
	IsOpt_cursor_fromContext()
}

type Opt_cursor_fromContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyOpt_cursor_fromContext() *Opt_cursor_fromContext {
	var p = new(Opt_cursor_fromContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opt_cursor_from
	return p
}

func InitEmptyOpt_cursor_fromContext(p *Opt_cursor_fromContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opt_cursor_from
}

func (*Opt_cursor_fromContext) IsOpt_cursor_fromContext() {}

func NewOpt_cursor_fromContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_cursor_fromContext {
	var p = new(Opt_cursor_fromContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_opt_cursor_from

	return p
}

func (s *Opt_cursor_fromContext) GetParser() antlr.Parser { return s.parser }

func (s *Opt_cursor_fromContext) FROM() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserFROM, 0)
}

func (s *Opt_cursor_fromContext) IN_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserIN_P, 0)
}

func (s *Opt_cursor_fromContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Opt_cursor_fromContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Opt_cursor_fromContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterOpt_cursor_from(s)
	}
}

func (s *Opt_cursor_fromContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitOpt_cursor_from(s)
	}
}

func (s *Opt_cursor_fromContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitOpt_cursor_from(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Opt_cursor_from() (localctx IOpt_cursor_fromContext) {
	localctx = NewOpt_cursor_fromContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1568, PostgreSQLParserRULE_opt_cursor_from)
	p.SetState(10550)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetTokenStream().LA(1) {
	case PostgreSQLParserPARAM, PostgreSQLParserAND, PostgreSQLParserARRAY, PostgreSQLParserCOLLATE, PostgreSQLParserCOLUMN, PostgreSQLParserCONSTRAINT, PostgreSQLParserDEFAULT, PostgreSQLParserDO, PostgreSQLParserFETCH, PostgreSQLParserTABLE, PostgreSQLParserIS, PostgreSQLParserLEFT, PostgreSQLParserOUTER_P, PostgreSQLParserOVER, PostgreSQLParserRIGHT, PostgreSQLParserABORT_P, PostgreSQLParserABSOLUTE_P, PostgreSQLParserACCESS, PostgreSQLParserACTION, PostgreSQLParserADD_P, PostgreSQLParserADMIN, PostgreSQLParserAFTER, PostgreSQLParserAGGREGATE, PostgreSQLParserALSO, PostgreSQLParserALTER, PostgreSQLParserALWAYS, PostgreSQLParserASSERTION, PostgreSQLParserASSIGNMENT, PostgreSQLParserAT, PostgreSQLParserATTRIBUTE, PostgreSQLParserBACKWARD, PostgreSQLParserBEFORE, PostgreSQLParserBEGIN_P, PostgreSQLParserBY, PostgreSQLParserCACHE, PostgreSQLParserCALLED, PostgreSQLParserCASCADE, PostgreSQLParserCASCADED, PostgreSQLParserCATALOG, PostgreSQLParserCHAIN, PostgreSQLParserCHARACTERISTICS, PostgreSQLParserCHECKPOINT, PostgreSQLParserCLASS, PostgreSQLParserCLOSE, PostgreSQLParserCLUSTER, PostgreSQLParserCOMMENT, PostgreSQLParserCOMMENTS, PostgreSQLParserCOMMIT, PostgreSQLParserCOMMITTED, PostgreSQLParserCONFIGURATION, PostgreSQLParserCONNECTION, PostgreSQLParserCONSTRAINTS, PostgreSQLParserCONTENT_P, PostgreSQLParserCONTINUE_P, PostgreSQLParserCONVERSION_P, PostgreSQLParserCOPY, PostgreSQLParserCOST, PostgreSQLParserCSV, PostgreSQLParserCURSOR, PostgreSQLParserCYCLE, PostgreSQLParserDATA_P, PostgreSQLParserDATABASE, PostgreSQLParserDAY_P, PostgreSQLParserDEALLOCATE, PostgreSQLParserDECLARE, PostgreSQLParserDEFAULTS, PostgreSQLParserDEFERRED, PostgreSQLParserDEFINER, PostgreSQLParserDELETE_P, PostgreSQLParserDELIMITER, PostgreSQLParserDELIMITERS, PostgreSQLParserDICTIONARY, PostgreSQLParserDISABLE_P, PostgreSQLParserDISCARD, PostgreSQLParserDOCUMENT_P, PostgreSQLParserDOMAIN_P, PostgreSQLParserDOUBLE_P, PostgreSQLParserDROP, PostgreSQLParserEACH, PostgreSQLParserENABLE_P, PostgreSQLParserENCODING, PostgreSQLParserENCRYPTED, PostgreSQLParserENUM_P, PostgreSQLParserESCAPE, PostgreSQLParserEVENT, PostgreSQLParserEXCLUDE, PostgreSQLParserEXCLUDING, PostgreSQLParserEXCLUSIVE, PostgreSQLParserEXECUTE, PostgreSQLParserEXPLAIN, PostgreSQLParserEXTENSION, PostgreSQLParserEXTERNAL, PostgreSQLParserFAMILY, PostgreSQLParserFIRST_P, PostgreSQLParserFOLLOWING, PostgreSQLParserFORCE, PostgreSQLParserFORWARD, PostgreSQLParserFUNCTION, PostgreSQLParserFUNCTIONS, PostgreSQLParserGLOBAL, PostgreSQLParserGRANTED, PostgreSQLParserHANDLER, PostgreSQLParserHEADER_P, PostgreSQLParserHOLD, PostgreSQLParserHOUR_P, PostgreSQLParserIDENTITY_P, PostgreSQLParserIF_P, PostgreSQLParserIMMEDIATE, PostgreSQLParserIMMUTABLE, PostgreSQLParserIMPLICIT_P, PostgreSQLParserINCLUDING, PostgreSQLParserINCREMENT, PostgreSQLParserINDEX, PostgreSQLParserINDEXES, PostgreSQLParserINHERIT, PostgreSQLParserINHERITS, PostgreSQLParserINLINE_P, PostgreSQLParserINSENSITIVE, PostgreSQLParserINSERT, PostgreSQLParserINSTEAD, PostgreSQLParserINVOKER, PostgreSQLParserISOLATION, PostgreSQLParserKEY, PostgreSQLParserLABEL, PostgreSQLParserLANGUAGE, PostgreSQLParserLARGE_P, PostgreSQLParserLAST_P, PostgreSQLParserLEAKPROOF, PostgreSQLParserLEVEL, PostgreSQLParserLISTEN, PostgreSQLParserLOAD, PostgreSQLParserLOCAL, PostgreSQLParserLOCATION, PostgreSQLParserLOCK_P, PostgreSQLParserMAPPING, PostgreSQLParserMATCH, PostgreSQLParserMATERIALIZED, PostgreSQLParserMAXVALUE, PostgreSQLParserMINUTE_P, PostgreSQLParserMINVALUE, PostgreSQLParserMODE, PostgreSQLParserMONTH_P, PostgreSQLParserMOVE, PostgreSQLParserNAME_P, PostgreSQLParserNAMES, PostgreSQLParserNEXT, PostgreSQLParserNO, PostgreSQLParserNOTHING, PostgreSQLParserNOTIFY, PostgreSQLParserNOWAIT, PostgreSQLParserNULLS_P, PostgreSQLParserOBJECT_P, PostgreSQLParserOF, PostgreSQLParserOFF, PostgreSQLParserOIDS, PostgreSQLParserOPERATOR, PostgreSQLParserOPTION, PostgreSQLParserOPTIONS, PostgreSQLParserOWNED, PostgreSQLParserOWNER, PostgreSQLParserPARSER, PostgreSQLParserPARTIAL, PostgreSQLParserPARTITION, PostgreSQLParserPASSING, PostgreSQLParserPASSWORD, PostgreSQLParserPLANS, PostgreSQLParserPRECEDING, PostgreSQLParserPREPARE, PostgreSQLParserPREPARED, PostgreSQLParserPRESERVE, PostgreSQLParserPRIOR, PostgreSQLParserPRIVILEGES, PostgreSQLParserPROCEDURAL, PostgreSQLParserPROCEDURE, PostgreSQLParserPROGRAM, PostgreSQLParserQUOTE, PostgreSQLParserRANGE, PostgreSQLParserREAD, PostgreSQLParserREASSIGN, PostgreSQLParserRECHECK, PostgreSQLParserRECURSIVE, PostgreSQLParserREF, PostgreSQLParserREFRESH, PostgreSQLParserREINDEX, PostgreSQLParserRELATIVE_P, PostgreSQLParserRELEASE, PostgreSQLParserRENAME, PostgreSQLParserREPEATABLE, PostgreSQLParserREPLACE, PostgreSQLParserREPLICA, PostgreSQLParserRESET, PostgreSQLParserRESTART, PostgreSQLParserRESTRICT, PostgreSQLParserRETURNS, PostgreSQLParserREVOKE, PostgreSQLParserROLE, PostgreSQLParserROLLBACK, PostgreSQLParserROWS, PostgreSQLParserRULE, PostgreSQLParserSAVEPOINT, PostgreSQLParserSCHEMA, PostgreSQLParserSCROLL, PostgreSQLParserSEARCH, PostgreSQLParserSECOND_P, PostgreSQLParserSECURITY, PostgreSQLParserSEQUENCE, PostgreSQLParserSEQUENCES, PostgreSQLParserSERIALIZABLE, PostgreSQLParserSERVER, PostgreSQLParserSESSION, PostgreSQLParserSET, PostgreSQLParserSHARE, PostgreSQLParserSHOW, PostgreSQLParserSIMPLE, PostgreSQLParserSNAPSHOT, PostgreSQLParserSTABLE, PostgreSQLParserSTANDALONE_P, PostgreSQLParserSTART, PostgreSQLParserSTATEMENT, PostgreSQLParserSTATISTICS, PostgreSQLParserSTDIN, PostgreSQLParserSTDOUT, PostgreSQLParserSTORAGE, PostgreSQLParserSTRICT_P, PostgreSQLParserSTRIP_P, PostgreSQLParserSYSID, PostgreSQLParserSYSTEM_P, PostgreSQLParserTABLES, PostgreSQLParserTABLESPACE, PostgreSQLParserTEMP, PostgreSQLParserTEMPLATE, PostgreSQLParserTEMPORARY, PostgreSQLParserTEXT_P, PostgreSQLParserTRANSACTION, PostgreSQLParserTRIGGER, PostgreSQLParserTRUNCATE, PostgreSQLParserTRUSTED, PostgreSQLParserTYPE_P, PostgreSQLParserTYPES_P, PostgreSQLParserUNBOUNDED, PostgreSQLParserUNCOMMITTED, PostgreSQLParserUNENCRYPTED, PostgreSQLParserUNKNOWN, PostgreSQLParserUNLISTEN, PostgreSQLParserUNLOGGED, PostgreSQLParserUNTIL, PostgreSQLParserUPDATE, PostgreSQLParserVACUUM, PostgreSQLParserVALID, PostgreSQLParserVALIDATE, PostgreSQLParserVALIDATOR, PostgreSQLParserVARYING, PostgreSQLParserVERSION_P, PostgreSQLParserVIEW, PostgreSQLParserVOLATILE, PostgreSQLParserWHITESPACE_P, PostgreSQLParserWITHOUT, PostgreSQLParserWORK, PostgreSQLParserWRAPPER, PostgreSQLParserWRITE, PostgreSQLParserXML_P, PostgreSQLParserYEAR_P, PostgreSQLParserYES_P, PostgreSQLParserZONE, PostgreSQLParserBETWEEN, PostgreSQLParserBIGINT, PostgreSQLParserBIT, PostgreSQLParserBOOLEAN_P, PostgreSQLParserCHAR_P, PostgreSQLParserCHARACTER, PostgreSQLParserCOALESCE, PostgreSQLParserDEC, PostgreSQLParserDECIMAL_P, PostgreSQLParserEXISTS, PostgreSQLParserEXTRACT, PostgreSQLParserFLOAT_P, PostgreSQLParserGREATEST, PostgreSQLParserINOUT, PostgreSQLParserINT_P, PostgreSQLParserINTEGER, PostgreSQLParserINTERVAL, PostgreSQLParserLEAST, PostgreSQLParserNATIONAL, PostgreSQLParserNCHAR, PostgreSQLParserNONE, PostgreSQLParserNULLIF, PostgreSQLParserNUMERIC, PostgreSQLParserOVERLAY, PostgreSQLParserPOSITION, PostgreSQLParserPRECISION, PostgreSQLParserREAL, PostgreSQLParserROW, PostgreSQLParserSETOF, PostgreSQLParserSMALLINT, PostgreSQLParserSUBSTRING, PostgreSQLParserTIME, PostgreSQLParserTIMESTAMP, PostgreSQLParserTREAT, PostgreSQLParserTRIM, PostgreSQLParserVALUES, PostgreSQLParserVARCHAR, PostgreSQLParserXMLATTRIBUTES, PostgreSQLParserXMLCOMMENT, PostgreSQLParserXMLAGG, PostgreSQLParserXML_IS_WELL_FORMED, PostgreSQLParserXML_IS_WELL_FORMED_DOCUMENT, PostgreSQLParserXML_IS_WELL_FORMED_CONTENT, PostgreSQLParserXPATH, PostgreSQLParserXPATH_EXISTS, PostgreSQLParserXMLCONCAT, PostgreSQLParserXMLELEMENT, PostgreSQLParserXMLEXISTS, PostgreSQLParserXMLFOREST, PostgreSQLParserXMLPARSE, PostgreSQLParserXMLPI, PostgreSQLParserXMLROOT, PostgreSQLParserXMLSERIALIZE, PostgreSQLParserCALL, PostgreSQLParserCURRENT_P, PostgreSQLParserATTACH, PostgreSQLParserDETACH, PostgreSQLParserEXPRESSION, PostgreSQLParserGENERATED, PostgreSQLParserLOGGED, PostgreSQLParserSTORED, PostgreSQLParserINCLUDE, PostgreSQLParserROUTINE, PostgreSQLParserTRANSFORM, PostgreSQLParserIMPORT_P, PostgreSQLParserPOLICY, PostgreSQLParserMETHOD, PostgreSQLParserREFERENCING, PostgreSQLParserNEW, PostgreSQLParserOLD, PostgreSQLParserVALUE_P, PostgreSQLParserSUBSCRIPTION, PostgreSQLParserPUBLICATION, PostgreSQLParserOUT_P, PostgreSQLParserROUTINES, PostgreSQLParserSCHEMAS, PostgreSQLParserPROCEDURES, PostgreSQLParserINPUT_P, PostgreSQLParserSUPPORT, PostgreSQLParserPARALLEL, PostgreSQLParserSQL_P, PostgreSQLParserDEPENDS, PostgreSQLParserOVERRIDING, PostgreSQLParserCONFLICT, PostgreSQLParserSKIP_P, PostgreSQLParserLOCKED, PostgreSQLParserTIES, PostgreSQLParserROLLUP, PostgreSQLParserCUBE, PostgreSQLParserGROUPING, PostgreSQLParserSETS, PostgreSQLParserORDINALITY, PostgreSQLParserXMLTABLE, PostgreSQLParserCOLUMNS, PostgreSQLParserXMLNAMESPACES, PostgreSQLParserROWTYPE, PostgreSQLParserNORMALIZED, PostgreSQLParserWITHIN, PostgreSQLParserFILTER, PostgreSQLParserGROUPS, PostgreSQLParserOTHERS, PostgreSQLParserNFC, PostgreSQLParserNFD, PostgreSQLParserNFKC, PostgreSQLParserNFKD, PostgreSQLParserUESCAPE, PostgreSQLParserVIEWS, PostgreSQLParserNORMALIZE, PostgreSQLParserDUMP, PostgreSQLParserPRINT_STRICT_PARAMS, PostgreSQLParserVARIABLE_CONFLICT, PostgreSQLParserERROR, PostgreSQLParserUSE_VARIABLE, PostgreSQLParserUSE_COLUMN, PostgreSQLParserALIAS, PostgreSQLParserCONSTANT, PostgreSQLParserPERFORM, PostgreSQLParserGET, PostgreSQLParserDIAGNOSTICS, PostgreSQLParserSTACKED, PostgreSQLParserELSIF, PostgreSQLParserREVERSE, PostgreSQLParserSLICE, PostgreSQLParserEXIT, PostgreSQLParserRETURN, PostgreSQLParserQUERY, PostgreSQLParserRAISE, PostgreSQLParserSQLSTATE, PostgreSQLParserDEBUG, PostgreSQLParserLOG, PostgreSQLParserINFO, PostgreSQLParserNOTICE, PostgreSQLParserWARNING, PostgreSQLParserEXCEPTION, PostgreSQLParserASSERT, PostgreSQLParserOPEN, PostgreSQLParserABS, PostgreSQLParserCBRT, PostgreSQLParserCEIL, PostgreSQLParserCEILING, PostgreSQLParserDEGREES, PostgreSQLParserDIV, PostgreSQLParserEXP, PostgreSQLParserFACTORIAL, PostgreSQLParserFLOOR, PostgreSQLParserGCD, PostgreSQLParserLCM, PostgreSQLParserLN, PostgreSQLParserLOG10, PostgreSQLParserMIN_SCALE, PostgreSQLParserMOD, PostgreSQLParserPI, PostgreSQLParserPOWER, PostgreSQLParserRADIANS, PostgreSQLParserROUND, PostgreSQLParserSCALE, PostgreSQLParserSIGN, PostgreSQLParserSQRT, PostgreSQLParserTRIM_SCALE, PostgreSQLParserTRUNC, PostgreSQLParserWIDTH_BUCKET, PostgreSQLParserRANDOM, PostgreSQLParserSETSEED, PostgreSQLParserACOS, PostgreSQLParserACOSD, PostgreSQLParserASIN, PostgreSQLParserASIND, PostgreSQLParserATAN, PostgreSQLParserATAND, PostgreSQLParserATAN2, PostgreSQLParserATAN2D, PostgreSQLParserCOS, PostgreSQLParserCOSD, PostgreSQLParserCOT, PostgreSQLParserCOTD, PostgreSQLParserSIN, PostgreSQLParserSIND, PostgreSQLParserTAN, PostgreSQLParserTAND, PostgreSQLParserSINH, PostgreSQLParserCOSH, PostgreSQLParserTANH, PostgreSQLParserASINH, PostgreSQLParserACOSH, PostgreSQLParserATANH, PostgreSQLParserBIT_LENGTH, PostgreSQLParserCHAR_LENGTH, PostgreSQLParserCHARACTER_LENGTH, PostgreSQLParserLOWER, PostgreSQLParserOCTET_LENGTH, PostgreSQLParserUPPER, PostgreSQLParserASCII, PostgreSQLParserBTRIM, PostgreSQLParserCHR, PostgreSQLParserCONCAT, PostgreSQLParserCONCAT_WS, PostgreSQLParserFORMAT, PostgreSQLParserINITCAP, PostgreSQLParserLENGTH, PostgreSQLParserLPAD, PostgreSQLParserLTRIM, PostgreSQLParserMD5, PostgreSQLParserPARSE_IDENT, PostgreSQLParserPG_CLIENT_ENCODING, PostgreSQLParserQUOTE_IDENT, PostgreSQLParserQUOTE_LITERAL, PostgreSQLParserQUOTE_NULLABLE, PostgreSQLParserREGEXP_COUNT, PostgreSQLParserREGEXP_INSTR, PostgreSQLParserREGEXP_LIKE, PostgreSQLParserREGEXP_MATCH, PostgreSQLParserREGEXP_MATCHES, PostgreSQLParserREGEXP_REPLACE, PostgreSQLParserREGEXP_SPLIT_TO_ARRAY, PostgreSQLParserREGEXP_SPLIT_TO_TABLE, PostgreSQLParserREGEXP_SUBSTR, PostgreSQLParserREPEAT, PostgreSQLParserRPAD, PostgreSQLParserRTRIM, PostgreSQLParserSPLIT_PART, PostgreSQLParserSTARTS_WITH, PostgreSQLParserSTRING_TO_ARRAY, PostgreSQLParserSTRING_TO_TABLE, PostgreSQLParserSTRPOS, PostgreSQLParserSUBSTR, PostgreSQLParserTO_ASCII, PostgreSQLParserTO_HEX, PostgreSQLParserTRANSLATE, PostgreSQLParserUNISTR, PostgreSQLParserAGE, PostgreSQLParserCLOCK_TIMESTAMP, PostgreSQLParserDATE_BIN, PostgreSQLParserDATE_PART, PostgreSQLParserDATE_TRUNC, PostgreSQLParserISFINITE, PostgreSQLParserJUSTIFY_DAYS, PostgreSQLParserJUSTIFY_HOURS, PostgreSQLParserJUSTIFY_INTERVAL, PostgreSQLParserMAKE_DATE, PostgreSQLParserMAKE_INTERVAL, PostgreSQLParserMAKE_TIME, PostgreSQLParserMAKE_TIMESTAMP, PostgreSQLParserMAKE_TIMESTAMPTZ, PostgreSQLParserNOW, PostgreSQLParserSTATEMENT_TIMESTAMP, PostgreSQLParserTIMEOFDAY, PostgreSQLParserTRANSACTION_TIMESTAMP, PostgreSQLParserTO_TIMESTAMP, PostgreSQLParserTO_CHAR, PostgreSQLParserTO_DATE, PostgreSQLParserTO_NUMBER, PostgreSQLParserIdentifier, PostgreSQLParserQuotedIdentifier, PostgreSQLParserUnicodeQuotedIdentifier, PostgreSQLParserPLSQLVARIABLENAME, PostgreSQLParserPLSQLIDENTIFIER:
		p.EnterOuterAlt(localctx, 1)

	case PostgreSQLParserFROM:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(10548)
			p.Match(PostgreSQLParserFROM)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case PostgreSQLParserIN_P:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(10549)
			p.Match(PostgreSQLParserIN_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	default:
		p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IOpt_fetch_directionContext is an interface to support dynamic dispatch.
type IOpt_fetch_directionContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	NEXT() antlr.TerminalNode
	PRIOR() antlr.TerminalNode
	FIRST_P() antlr.TerminalNode
	LAST_P() antlr.TerminalNode
	ABSOLUTE_P() antlr.TerminalNode
	A_expr() IA_exprContext
	RELATIVE_P() antlr.TerminalNode
	ALL() antlr.TerminalNode
	FORWARD() antlr.TerminalNode
	BACKWARD() antlr.TerminalNode

	// IsOpt_fetch_directionContext differentiates from other interfaces.
	IsOpt_fetch_directionContext()
}

type Opt_fetch_directionContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyOpt_fetch_directionContext() *Opt_fetch_directionContext {
	var p = new(Opt_fetch_directionContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opt_fetch_direction
	return p
}

func InitEmptyOpt_fetch_directionContext(p *Opt_fetch_directionContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opt_fetch_direction
}

func (*Opt_fetch_directionContext) IsOpt_fetch_directionContext() {}

func NewOpt_fetch_directionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_fetch_directionContext {
	var p = new(Opt_fetch_directionContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_opt_fetch_direction

	return p
}

func (s *Opt_fetch_directionContext) GetParser() antlr.Parser { return s.parser }

func (s *Opt_fetch_directionContext) NEXT() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserNEXT, 0)
}

func (s *Opt_fetch_directionContext) PRIOR() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserPRIOR, 0)
}

func (s *Opt_fetch_directionContext) FIRST_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserFIRST_P, 0)
}

func (s *Opt_fetch_directionContext) LAST_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserLAST_P, 0)
}

func (s *Opt_fetch_directionContext) ABSOLUTE_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserABSOLUTE_P, 0)
}

func (s *Opt_fetch_directionContext) A_expr() IA_exprContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IA_exprContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IA_exprContext)
}

func (s *Opt_fetch_directionContext) RELATIVE_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserRELATIVE_P, 0)
}

func (s *Opt_fetch_directionContext) ALL() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserALL, 0)
}

func (s *Opt_fetch_directionContext) FORWARD() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserFORWARD, 0)
}

func (s *Opt_fetch_directionContext) BACKWARD() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserBACKWARD, 0)
}

func (s *Opt_fetch_directionContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Opt_fetch_directionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Opt_fetch_directionContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterOpt_fetch_direction(s)
	}
}

func (s *Opt_fetch_directionContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitOpt_fetch_direction(s)
	}
}

func (s *Opt_fetch_directionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitOpt_fetch_direction(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Opt_fetch_direction() (localctx IOpt_fetch_directionContext) {
	localctx = NewOpt_fetch_directionContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1570, PostgreSQLParserRULE_opt_fetch_direction)
	var _la int

	p.SetState(10569)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 728, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)

	case 2:
		p.EnterOuterAlt(localctx, 2)

	case 3:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(10554)
			p.Match(PostgreSQLParserNEXT)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 4:
		p.EnterOuterAlt(localctx, 4)
		{
			p.SetState(10555)
			p.Match(PostgreSQLParserPRIOR)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 5:
		p.EnterOuterAlt(localctx, 5)
		{
			p.SetState(10556)
			p.Match(PostgreSQLParserFIRST_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 6:
		p.EnterOuterAlt(localctx, 6)
		{
			p.SetState(10557)
			p.Match(PostgreSQLParserLAST_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 7:
		p.EnterOuterAlt(localctx, 7)
		{
			p.SetState(10558)
			p.Match(PostgreSQLParserABSOLUTE_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(10559)
			p.A_expr()
		}

	case 8:
		p.EnterOuterAlt(localctx, 8)
		{
			p.SetState(10560)
			p.Match(PostgreSQLParserRELATIVE_P)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(10561)
			p.A_expr()
		}

	case 9:
		p.EnterOuterAlt(localctx, 9)
		{
			p.SetState(10562)
			p.A_expr()
		}

	case 10:
		p.EnterOuterAlt(localctx, 10)
		{
			p.SetState(10563)
			p.Match(PostgreSQLParserALL)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case 11:
		p.EnterOuterAlt(localctx, 11)
		{
			p.SetState(10564)
			_la = p.GetTokenStream().LA(1)

			if !(_la == PostgreSQLParserBACKWARD || _la == PostgreSQLParserFORWARD) {
				p.GetErrorHandler().RecoverInline(p)
			} else {
				p.GetErrorHandler().ReportMatch(p)
				p.Consume()
			}
		}
		p.SetState(10567)
		p.GetErrorHandler().Sync(p)

		if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 727, p.GetParserRuleContext()) == 1 {
			{
				p.SetState(10565)
				p.A_expr()
			}

		} else if p.HasError() { // JIM
			goto errorExit
		} else if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 727, p.GetParserRuleContext()) == 2 {
			{
				p.SetState(10566)
				p.Match(PostgreSQLParserALL)
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}

		} else if p.HasError() { // JIM
			goto errorExit
		}

	case antlr.ATNInvalidAltNumber:
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IStmt_moveContext is an interface to support dynamic dispatch.
type IStmt_moveContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	MOVE() antlr.TerminalNode
	Opt_fetch_direction() IOpt_fetch_directionContext
	Cursor_variable() ICursor_variableContext
	SEMI() antlr.TerminalNode

	// IsStmt_moveContext differentiates from other interfaces.
	IsStmt_moveContext()
}

type Stmt_moveContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyStmt_moveContext() *Stmt_moveContext {
	var p = new(Stmt_moveContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_stmt_move
	return p
}

func InitEmptyStmt_moveContext(p *Stmt_moveContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_stmt_move
}

func (*Stmt_moveContext) IsStmt_moveContext() {}

func NewStmt_moveContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Stmt_moveContext {
	var p = new(Stmt_moveContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_stmt_move

	return p
}

func (s *Stmt_moveContext) GetParser() antlr.Parser { return s.parser }

func (s *Stmt_moveContext) MOVE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserMOVE, 0)
}

func (s *Stmt_moveContext) Opt_fetch_direction() IOpt_fetch_directionContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOpt_fetch_directionContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOpt_fetch_directionContext)
}

func (s *Stmt_moveContext) Cursor_variable() ICursor_variableContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ICursor_variableContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ICursor_variableContext)
}

func (s *Stmt_moveContext) SEMI() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserSEMI, 0)
}

func (s *Stmt_moveContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Stmt_moveContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Stmt_moveContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterStmt_move(s)
	}
}

func (s *Stmt_moveContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitStmt_move(s)
	}
}

func (s *Stmt_moveContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitStmt_move(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Stmt_move() (localctx IStmt_moveContext) {
	localctx = NewStmt_moveContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1572, PostgreSQLParserRULE_stmt_move)
	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(10571)
		p.Match(PostgreSQLParserMOVE)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(10572)
		p.Opt_fetch_direction()
	}
	{
		p.SetState(10573)
		p.Cursor_variable()
	}
	{
		p.SetState(10574)
		p.Match(PostgreSQLParserSEMI)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IStmt_closeContext is an interface to support dynamic dispatch.
type IStmt_closeContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	CLOSE() antlr.TerminalNode
	Cursor_variable() ICursor_variableContext
	SEMI() antlr.TerminalNode

	// IsStmt_closeContext differentiates from other interfaces.
	IsStmt_closeContext()
}

type Stmt_closeContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyStmt_closeContext() *Stmt_closeContext {
	var p = new(Stmt_closeContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_stmt_close
	return p
}

func InitEmptyStmt_closeContext(p *Stmt_closeContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_stmt_close
}

func (*Stmt_closeContext) IsStmt_closeContext() {}

func NewStmt_closeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Stmt_closeContext {
	var p = new(Stmt_closeContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_stmt_close

	return p
}

func (s *Stmt_closeContext) GetParser() antlr.Parser { return s.parser }

func (s *Stmt_closeContext) CLOSE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCLOSE, 0)
}

func (s *Stmt_closeContext) Cursor_variable() ICursor_variableContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ICursor_variableContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ICursor_variableContext)
}

func (s *Stmt_closeContext) SEMI() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserSEMI, 0)
}

func (s *Stmt_closeContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Stmt_closeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Stmt_closeContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterStmt_close(s)
	}
}

func (s *Stmt_closeContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitStmt_close(s)
	}
}

func (s *Stmt_closeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitStmt_close(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Stmt_close() (localctx IStmt_closeContext) {
	localctx = NewStmt_closeContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1574, PostgreSQLParserRULE_stmt_close)
	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(10576)
		p.Match(PostgreSQLParserCLOSE)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(10577)
		p.Cursor_variable()
	}
	{
		p.SetState(10578)
		p.Match(PostgreSQLParserSEMI)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IStmt_nullContext is an interface to support dynamic dispatch.
type IStmt_nullContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	NULL_P() antlr.TerminalNode
	SEMI() antlr.TerminalNode

	// IsStmt_nullContext differentiates from other interfaces.
	IsStmt_nullContext()
}

type Stmt_nullContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyStmt_nullContext() *Stmt_nullContext {
	var p = new(Stmt_nullContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_stmt_null
	return p
}

func InitEmptyStmt_nullContext(p *Stmt_nullContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_stmt_null
}

func (*Stmt_nullContext) IsStmt_nullContext() {}

func NewStmt_nullContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Stmt_nullContext {
	var p = new(Stmt_nullContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_stmt_null

	return p
}

func (s *Stmt_nullContext) GetParser() antlr.Parser { return s.parser }

func (s *Stmt_nullContext) NULL_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserNULL_P, 0)
}

func (s *Stmt_nullContext) SEMI() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserSEMI, 0)
}

func (s *Stmt_nullContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Stmt_nullContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Stmt_nullContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterStmt_null(s)
	}
}

func (s *Stmt_nullContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitStmt_null(s)
	}
}

func (s *Stmt_nullContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitStmt_null(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Stmt_null() (localctx IStmt_nullContext) {
	localctx = NewStmt_nullContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1576, PostgreSQLParserRULE_stmt_null)
	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(10580)
		p.Match(PostgreSQLParserNULL_P)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(10581)
		p.Match(PostgreSQLParserSEMI)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IStmt_commitContext is an interface to support dynamic dispatch.
type IStmt_commitContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	COMMIT() antlr.TerminalNode
	Plsql_opt_transaction_chain() IPlsql_opt_transaction_chainContext
	SEMI() antlr.TerminalNode

	// IsStmt_commitContext differentiates from other interfaces.
	IsStmt_commitContext()
}

type Stmt_commitContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyStmt_commitContext() *Stmt_commitContext {
	var p = new(Stmt_commitContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_stmt_commit
	return p
}

func InitEmptyStmt_commitContext(p *Stmt_commitContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_stmt_commit
}

func (*Stmt_commitContext) IsStmt_commitContext() {}

func NewStmt_commitContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Stmt_commitContext {
	var p = new(Stmt_commitContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_stmt_commit

	return p
}

func (s *Stmt_commitContext) GetParser() antlr.Parser { return s.parser }

func (s *Stmt_commitContext) COMMIT() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCOMMIT, 0)
}

func (s *Stmt_commitContext) Plsql_opt_transaction_chain() IPlsql_opt_transaction_chainContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IPlsql_opt_transaction_chainContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IPlsql_opt_transaction_chainContext)
}

func (s *Stmt_commitContext) SEMI() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserSEMI, 0)
}

func (s *Stmt_commitContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Stmt_commitContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Stmt_commitContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterStmt_commit(s)
	}
}

func (s *Stmt_commitContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitStmt_commit(s)
	}
}

func (s *Stmt_commitContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitStmt_commit(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Stmt_commit() (localctx IStmt_commitContext) {
	localctx = NewStmt_commitContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1578, PostgreSQLParserRULE_stmt_commit)
	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(10583)
		p.Match(PostgreSQLParserCOMMIT)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(10584)
		p.Plsql_opt_transaction_chain()
	}
	{
		p.SetState(10585)
		p.Match(PostgreSQLParserSEMI)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IStmt_rollbackContext is an interface to support dynamic dispatch.
type IStmt_rollbackContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	ROLLBACK() antlr.TerminalNode
	Plsql_opt_transaction_chain() IPlsql_opt_transaction_chainContext
	SEMI() antlr.TerminalNode

	// IsStmt_rollbackContext differentiates from other interfaces.
	IsStmt_rollbackContext()
}

type Stmt_rollbackContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyStmt_rollbackContext() *Stmt_rollbackContext {
	var p = new(Stmt_rollbackContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_stmt_rollback
	return p
}

func InitEmptyStmt_rollbackContext(p *Stmt_rollbackContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_stmt_rollback
}

func (*Stmt_rollbackContext) IsStmt_rollbackContext() {}

func NewStmt_rollbackContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Stmt_rollbackContext {
	var p = new(Stmt_rollbackContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_stmt_rollback

	return p
}

func (s *Stmt_rollbackContext) GetParser() antlr.Parser { return s.parser }

func (s *Stmt_rollbackContext) ROLLBACK() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserROLLBACK, 0)
}

func (s *Stmt_rollbackContext) Plsql_opt_transaction_chain() IPlsql_opt_transaction_chainContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IPlsql_opt_transaction_chainContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IPlsql_opt_transaction_chainContext)
}

func (s *Stmt_rollbackContext) SEMI() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserSEMI, 0)
}

func (s *Stmt_rollbackContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Stmt_rollbackContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Stmt_rollbackContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterStmt_rollback(s)
	}
}

func (s *Stmt_rollbackContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitStmt_rollback(s)
	}
}

func (s *Stmt_rollbackContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitStmt_rollback(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Stmt_rollback() (localctx IStmt_rollbackContext) {
	localctx = NewStmt_rollbackContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1580, PostgreSQLParserRULE_stmt_rollback)
	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(10587)
		p.Match(PostgreSQLParserROLLBACK)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(10588)
		p.Plsql_opt_transaction_chain()
	}
	{
		p.SetState(10589)
		p.Match(PostgreSQLParserSEMI)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IPlsql_opt_transaction_chainContext is an interface to support dynamic dispatch.
type IPlsql_opt_transaction_chainContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	AND() antlr.TerminalNode
	CHAIN() antlr.TerminalNode
	NO() antlr.TerminalNode

	// IsPlsql_opt_transaction_chainContext differentiates from other interfaces.
	IsPlsql_opt_transaction_chainContext()
}

type Plsql_opt_transaction_chainContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyPlsql_opt_transaction_chainContext() *Plsql_opt_transaction_chainContext {
	var p = new(Plsql_opt_transaction_chainContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_plsql_opt_transaction_chain
	return p
}

func InitEmptyPlsql_opt_transaction_chainContext(p *Plsql_opt_transaction_chainContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_plsql_opt_transaction_chain
}

func (*Plsql_opt_transaction_chainContext) IsPlsql_opt_transaction_chainContext() {}

func NewPlsql_opt_transaction_chainContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Plsql_opt_transaction_chainContext {
	var p = new(Plsql_opt_transaction_chainContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_plsql_opt_transaction_chain

	return p
}

func (s *Plsql_opt_transaction_chainContext) GetParser() antlr.Parser { return s.parser }

func (s *Plsql_opt_transaction_chainContext) AND() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserAND, 0)
}

func (s *Plsql_opt_transaction_chainContext) CHAIN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCHAIN, 0)
}

func (s *Plsql_opt_transaction_chainContext) NO() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserNO, 0)
}

func (s *Plsql_opt_transaction_chainContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Plsql_opt_transaction_chainContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Plsql_opt_transaction_chainContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterPlsql_opt_transaction_chain(s)
	}
}

func (s *Plsql_opt_transaction_chainContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitPlsql_opt_transaction_chain(s)
	}
}

func (s *Plsql_opt_transaction_chainContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitPlsql_opt_transaction_chain(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Plsql_opt_transaction_chain() (localctx IPlsql_opt_transaction_chainContext) {
	localctx = NewPlsql_opt_transaction_chainContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1582, PostgreSQLParserRULE_plsql_opt_transaction_chain)
	var _la int

	p.SetState(10597)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetTokenStream().LA(1) {
	case PostgreSQLParserAND:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(10591)
			p.Match(PostgreSQLParserAND)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		p.SetState(10593)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}
		_la = p.GetTokenStream().LA(1)

		if _la == PostgreSQLParserNO {
			{
				p.SetState(10592)
				p.Match(PostgreSQLParserNO)
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}

		}
		{
			p.SetState(10595)
			p.Match(PostgreSQLParserCHAIN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case PostgreSQLParserSEMI:
		p.EnterOuterAlt(localctx, 2)

	default:
		p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IStmt_setContext is an interface to support dynamic dispatch.
type IStmt_setContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	SET() antlr.TerminalNode
	Any_name() IAny_nameContext
	TO() antlr.TerminalNode
	DEFAULT() antlr.TerminalNode
	SEMI() antlr.TerminalNode
	RESET() antlr.TerminalNode
	ALL() antlr.TerminalNode

	// IsStmt_setContext differentiates from other interfaces.
	IsStmt_setContext()
}

type Stmt_setContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyStmt_setContext() *Stmt_setContext {
	var p = new(Stmt_setContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_stmt_set
	return p
}

func InitEmptyStmt_setContext(p *Stmt_setContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_stmt_set
}

func (*Stmt_setContext) IsStmt_setContext() {}

func NewStmt_setContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Stmt_setContext {
	var p = new(Stmt_setContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_stmt_set

	return p
}

func (s *Stmt_setContext) GetParser() antlr.Parser { return s.parser }

func (s *Stmt_setContext) SET() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserSET, 0)
}

func (s *Stmt_setContext) Any_name() IAny_nameContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IAny_nameContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IAny_nameContext)
}

func (s *Stmt_setContext) TO() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserTO, 0)
}

func (s *Stmt_setContext) DEFAULT() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserDEFAULT, 0)
}

func (s *Stmt_setContext) SEMI() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserSEMI, 0)
}

func (s *Stmt_setContext) RESET() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserRESET, 0)
}

func (s *Stmt_setContext) ALL() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserALL, 0)
}

func (s *Stmt_setContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Stmt_setContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Stmt_setContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterStmt_set(s)
	}
}

func (s *Stmt_setContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitStmt_set(s)
	}
}

func (s *Stmt_setContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitStmt_set(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Stmt_set() (localctx IStmt_setContext) {
	localctx = NewStmt_setContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1584, PostgreSQLParserRULE_stmt_set)
	p.SetState(10611)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetTokenStream().LA(1) {
	case PostgreSQLParserSET:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(10599)
			p.Match(PostgreSQLParserSET)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(10600)
			p.Any_name()
		}
		{
			p.SetState(10601)
			p.Match(PostgreSQLParserTO)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(10602)
			p.Match(PostgreSQLParserDEFAULT)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(10603)
			p.Match(PostgreSQLParserSEMI)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	case PostgreSQLParserRESET:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(10605)
			p.Match(PostgreSQLParserRESET)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		p.SetState(10608)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}

		switch p.GetTokenStream().LA(1) {
		case PostgreSQLParserAND, PostgreSQLParserARRAY, PostgreSQLParserCOLLATE, PostgreSQLParserCOLUMN, PostgreSQLParserCONSTRAINT, PostgreSQLParserDEFAULT, PostgreSQLParserDO, PostgreSQLParserFETCH, PostgreSQLParserTABLE, PostgreSQLParserIS, PostgreSQLParserLEFT, PostgreSQLParserOUTER_P, PostgreSQLParserOVER, PostgreSQLParserRIGHT, PostgreSQLParserABORT_P, PostgreSQLParserABSOLUTE_P, PostgreSQLParserACCESS, PostgreSQLParserACTION, PostgreSQLParserADD_P, PostgreSQLParserADMIN, PostgreSQLParserAFTER, PostgreSQLParserAGGREGATE, PostgreSQLParserALSO, PostgreSQLParserALTER, PostgreSQLParserALWAYS, PostgreSQLParserASSERTION, PostgreSQLParserASSIGNMENT, PostgreSQLParserAT, PostgreSQLParserATTRIBUTE, PostgreSQLParserBACKWARD, PostgreSQLParserBEFORE, PostgreSQLParserBEGIN_P, PostgreSQLParserBY, PostgreSQLParserCACHE, PostgreSQLParserCALLED, PostgreSQLParserCASCADE, PostgreSQLParserCASCADED, PostgreSQLParserCATALOG, PostgreSQLParserCHAIN, PostgreSQLParserCHARACTERISTICS, PostgreSQLParserCHECKPOINT, PostgreSQLParserCLASS, PostgreSQLParserCLOSE, PostgreSQLParserCLUSTER, PostgreSQLParserCOMMENT, PostgreSQLParserCOMMENTS, PostgreSQLParserCOMMIT, PostgreSQLParserCOMMITTED, PostgreSQLParserCONFIGURATION, PostgreSQLParserCONNECTION, PostgreSQLParserCONSTRAINTS, PostgreSQLParserCONTENT_P, PostgreSQLParserCONTINUE_P, PostgreSQLParserCONVERSION_P, PostgreSQLParserCOPY, PostgreSQLParserCOST, PostgreSQLParserCSV, PostgreSQLParserCURSOR, PostgreSQLParserCYCLE, PostgreSQLParserDATA_P, PostgreSQLParserDATABASE, PostgreSQLParserDAY_P, PostgreSQLParserDEALLOCATE, PostgreSQLParserDECLARE, PostgreSQLParserDEFAULTS, PostgreSQLParserDEFERRED, PostgreSQLParserDEFINER, PostgreSQLParserDELETE_P, PostgreSQLParserDELIMITER, PostgreSQLParserDELIMITERS, PostgreSQLParserDICTIONARY, PostgreSQLParserDISABLE_P, PostgreSQLParserDISCARD, PostgreSQLParserDOCUMENT_P, PostgreSQLParserDOMAIN_P, PostgreSQLParserDOUBLE_P, PostgreSQLParserDROP, PostgreSQLParserEACH, PostgreSQLParserENABLE_P, PostgreSQLParserENCODING, PostgreSQLParserENCRYPTED, PostgreSQLParserENUM_P, PostgreSQLParserESCAPE, PostgreSQLParserEVENT, PostgreSQLParserEXCLUDE, PostgreSQLParserEXCLUDING, PostgreSQLParserEXCLUSIVE, PostgreSQLParserEXECUTE, PostgreSQLParserEXPLAIN, PostgreSQLParserEXTENSION, PostgreSQLParserEXTERNAL, PostgreSQLParserFAMILY, PostgreSQLParserFIRST_P, PostgreSQLParserFOLLOWING, PostgreSQLParserFORCE, PostgreSQLParserFORWARD, PostgreSQLParserFUNCTION, PostgreSQLParserFUNCTIONS, PostgreSQLParserGLOBAL, PostgreSQLParserGRANTED, PostgreSQLParserHANDLER, PostgreSQLParserHEADER_P, PostgreSQLParserHOLD, PostgreSQLParserHOUR_P, PostgreSQLParserIDENTITY_P, PostgreSQLParserIF_P, PostgreSQLParserIMMEDIATE, PostgreSQLParserIMMUTABLE, PostgreSQLParserIMPLICIT_P, PostgreSQLParserINCLUDING, PostgreSQLParserINCREMENT, PostgreSQLParserINDEX, PostgreSQLParserINDEXES, PostgreSQLParserINHERIT, PostgreSQLParserINHERITS, PostgreSQLParserINLINE_P, PostgreSQLParserINSENSITIVE, PostgreSQLParserINSERT, PostgreSQLParserINSTEAD, PostgreSQLParserINVOKER, PostgreSQLParserISOLATION, PostgreSQLParserKEY, PostgreSQLParserLABEL, PostgreSQLParserLANGUAGE, PostgreSQLParserLARGE_P, PostgreSQLParserLAST_P, PostgreSQLParserLEAKPROOF, PostgreSQLParserLEVEL, PostgreSQLParserLISTEN, PostgreSQLParserLOAD, PostgreSQLParserLOCAL, PostgreSQLParserLOCATION, PostgreSQLParserLOCK_P, PostgreSQLParserMAPPING, PostgreSQLParserMATCH, PostgreSQLParserMATERIALIZED, PostgreSQLParserMAXVALUE, PostgreSQLParserMINUTE_P, PostgreSQLParserMINVALUE, PostgreSQLParserMODE, PostgreSQLParserMONTH_P, PostgreSQLParserMOVE, PostgreSQLParserNAME_P, PostgreSQLParserNAMES, PostgreSQLParserNEXT, PostgreSQLParserNO, PostgreSQLParserNOTHING, PostgreSQLParserNOTIFY, PostgreSQLParserNOWAIT, PostgreSQLParserNULLS_P, PostgreSQLParserOBJECT_P, PostgreSQLParserOF, PostgreSQLParserOFF, PostgreSQLParserOIDS, PostgreSQLParserOPERATOR, PostgreSQLParserOPTION, PostgreSQLParserOPTIONS, PostgreSQLParserOWNED, PostgreSQLParserOWNER, PostgreSQLParserPARSER, PostgreSQLParserPARTIAL, PostgreSQLParserPARTITION, PostgreSQLParserPASSING, PostgreSQLParserPASSWORD, PostgreSQLParserPLANS, PostgreSQLParserPRECEDING, PostgreSQLParserPREPARE, PostgreSQLParserPREPARED, PostgreSQLParserPRESERVE, PostgreSQLParserPRIOR, PostgreSQLParserPRIVILEGES, PostgreSQLParserPROCEDURAL, PostgreSQLParserPROCEDURE, PostgreSQLParserPROGRAM, PostgreSQLParserQUOTE, PostgreSQLParserRANGE, PostgreSQLParserREAD, PostgreSQLParserREASSIGN, PostgreSQLParserRECHECK, PostgreSQLParserRECURSIVE, PostgreSQLParserREF, PostgreSQLParserREFRESH, PostgreSQLParserREINDEX, PostgreSQLParserRELATIVE_P, PostgreSQLParserRELEASE, PostgreSQLParserRENAME, PostgreSQLParserREPEATABLE, PostgreSQLParserREPLACE, PostgreSQLParserREPLICA, PostgreSQLParserRESET, PostgreSQLParserRESTART, PostgreSQLParserRESTRICT, PostgreSQLParserRETURNS, PostgreSQLParserREVOKE, PostgreSQLParserROLE, PostgreSQLParserROLLBACK, PostgreSQLParserROWS, PostgreSQLParserRULE, PostgreSQLParserSAVEPOINT, PostgreSQLParserSCHEMA, PostgreSQLParserSCROLL, PostgreSQLParserSEARCH, PostgreSQLParserSECOND_P, PostgreSQLParserSECURITY, PostgreSQLParserSEQUENCE, PostgreSQLParserSEQUENCES, PostgreSQLParserSERIALIZABLE, PostgreSQLParserSERVER, PostgreSQLParserSESSION, PostgreSQLParserSET, PostgreSQLParserSHARE, PostgreSQLParserSHOW, PostgreSQLParserSIMPLE, PostgreSQLParserSNAPSHOT, PostgreSQLParserSTABLE, PostgreSQLParserSTANDALONE_P, PostgreSQLParserSTART, PostgreSQLParserSTATEMENT, PostgreSQLParserSTATISTICS, PostgreSQLParserSTDIN, PostgreSQLParserSTDOUT, PostgreSQLParserSTORAGE, PostgreSQLParserSTRICT_P, PostgreSQLParserSTRIP_P, PostgreSQLParserSYSID, PostgreSQLParserSYSTEM_P, PostgreSQLParserTABLES, PostgreSQLParserTABLESPACE, PostgreSQLParserTEMP, PostgreSQLParserTEMPLATE, PostgreSQLParserTEMPORARY, PostgreSQLParserTEXT_P, PostgreSQLParserTRANSACTION, PostgreSQLParserTRIGGER, PostgreSQLParserTRUNCATE, PostgreSQLParserTRUSTED, PostgreSQLParserTYPE_P, PostgreSQLParserTYPES_P, PostgreSQLParserUNBOUNDED, PostgreSQLParserUNCOMMITTED, PostgreSQLParserUNENCRYPTED, PostgreSQLParserUNKNOWN, PostgreSQLParserUNLISTEN, PostgreSQLParserUNLOGGED, PostgreSQLParserUNTIL, PostgreSQLParserUPDATE, PostgreSQLParserVACUUM, PostgreSQLParserVALID, PostgreSQLParserVALIDATE, PostgreSQLParserVALIDATOR, PostgreSQLParserVARYING, PostgreSQLParserVERSION_P, PostgreSQLParserVIEW, PostgreSQLParserVOLATILE, PostgreSQLParserWHITESPACE_P, PostgreSQLParserWITHOUT, PostgreSQLParserWORK, PostgreSQLParserWRAPPER, PostgreSQLParserWRITE, PostgreSQLParserXML_P, PostgreSQLParserYEAR_P, PostgreSQLParserYES_P, PostgreSQLParserZONE, PostgreSQLParserBETWEEN, PostgreSQLParserBIGINT, PostgreSQLParserBIT, PostgreSQLParserBOOLEAN_P, PostgreSQLParserCHAR_P, PostgreSQLParserCHARACTER, PostgreSQLParserCOALESCE, PostgreSQLParserDEC, PostgreSQLParserDECIMAL_P, PostgreSQLParserEXISTS, PostgreSQLParserEXTRACT, PostgreSQLParserFLOAT_P, PostgreSQLParserGREATEST, PostgreSQLParserINOUT, PostgreSQLParserINT_P, PostgreSQLParserINTEGER, PostgreSQLParserINTERVAL, PostgreSQLParserLEAST, PostgreSQLParserNATIONAL, PostgreSQLParserNCHAR, PostgreSQLParserNONE, PostgreSQLParserNULLIF, PostgreSQLParserNUMERIC, PostgreSQLParserOVERLAY, PostgreSQLParserPOSITION, PostgreSQLParserPRECISION, PostgreSQLParserREAL, PostgreSQLParserROW, PostgreSQLParserSETOF, PostgreSQLParserSMALLINT, PostgreSQLParserSUBSTRING, PostgreSQLParserTIME, PostgreSQLParserTIMESTAMP, PostgreSQLParserTREAT, PostgreSQLParserTRIM, PostgreSQLParserVALUES, PostgreSQLParserVARCHAR, PostgreSQLParserXMLATTRIBUTES, PostgreSQLParserXMLCOMMENT, PostgreSQLParserXMLAGG, PostgreSQLParserXML_IS_WELL_FORMED, PostgreSQLParserXML_IS_WELL_FORMED_DOCUMENT, PostgreSQLParserXML_IS_WELL_FORMED_CONTENT, PostgreSQLParserXPATH, PostgreSQLParserXPATH_EXISTS, PostgreSQLParserXMLCONCAT, PostgreSQLParserXMLELEMENT, PostgreSQLParserXMLEXISTS, PostgreSQLParserXMLFOREST, PostgreSQLParserXMLPARSE, PostgreSQLParserXMLPI, PostgreSQLParserXMLROOT, PostgreSQLParserXMLSERIALIZE, PostgreSQLParserCALL, PostgreSQLParserCURRENT_P, PostgreSQLParserATTACH, PostgreSQLParserDETACH, PostgreSQLParserEXPRESSION, PostgreSQLParserGENERATED, PostgreSQLParserLOGGED, PostgreSQLParserSTORED, PostgreSQLParserINCLUDE, PostgreSQLParserROUTINE, PostgreSQLParserTRANSFORM, PostgreSQLParserIMPORT_P, PostgreSQLParserPOLICY, PostgreSQLParserMETHOD, PostgreSQLParserREFERENCING, PostgreSQLParserNEW, PostgreSQLParserOLD, PostgreSQLParserVALUE_P, PostgreSQLParserSUBSCRIPTION, PostgreSQLParserPUBLICATION, PostgreSQLParserOUT_P, PostgreSQLParserROUTINES, PostgreSQLParserSCHEMAS, PostgreSQLParserPROCEDURES, PostgreSQLParserINPUT_P, PostgreSQLParserSUPPORT, PostgreSQLParserPARALLEL, PostgreSQLParserSQL_P, PostgreSQLParserDEPENDS, PostgreSQLParserOVERRIDING, PostgreSQLParserCONFLICT, PostgreSQLParserSKIP_P, PostgreSQLParserLOCKED, PostgreSQLParserTIES, PostgreSQLParserROLLUP, PostgreSQLParserCUBE, PostgreSQLParserGROUPING, PostgreSQLParserSETS, PostgreSQLParserORDINALITY, PostgreSQLParserXMLTABLE, PostgreSQLParserCOLUMNS, PostgreSQLParserXMLNAMESPACES, PostgreSQLParserROWTYPE, PostgreSQLParserNORMALIZED, PostgreSQLParserWITHIN, PostgreSQLParserFILTER, PostgreSQLParserGROUPS, PostgreSQLParserOTHERS, PostgreSQLParserNFC, PostgreSQLParserNFD, PostgreSQLParserNFKC, PostgreSQLParserNFKD, PostgreSQLParserUESCAPE, PostgreSQLParserVIEWS, PostgreSQLParserNORMALIZE, PostgreSQLParserDUMP, PostgreSQLParserPRINT_STRICT_PARAMS, PostgreSQLParserVARIABLE_CONFLICT, PostgreSQLParserERROR, PostgreSQLParserUSE_VARIABLE, PostgreSQLParserUSE_COLUMN, PostgreSQLParserALIAS, PostgreSQLParserCONSTANT, PostgreSQLParserPERFORM, PostgreSQLParserGET, PostgreSQLParserDIAGNOSTICS, PostgreSQLParserSTACKED, PostgreSQLParserELSIF, PostgreSQLParserREVERSE, PostgreSQLParserSLICE, PostgreSQLParserEXIT, PostgreSQLParserRETURN, PostgreSQLParserQUERY, PostgreSQLParserRAISE, PostgreSQLParserSQLSTATE, PostgreSQLParserDEBUG, PostgreSQLParserLOG, PostgreSQLParserINFO, PostgreSQLParserNOTICE, PostgreSQLParserWARNING, PostgreSQLParserEXCEPTION, PostgreSQLParserASSERT, PostgreSQLParserOPEN, PostgreSQLParserABS, PostgreSQLParserCBRT, PostgreSQLParserCEIL, PostgreSQLParserCEILING, PostgreSQLParserDEGREES, PostgreSQLParserDIV, PostgreSQLParserEXP, PostgreSQLParserFACTORIAL, PostgreSQLParserFLOOR, PostgreSQLParserGCD, PostgreSQLParserLCM, PostgreSQLParserLN, PostgreSQLParserLOG10, PostgreSQLParserMIN_SCALE, PostgreSQLParserMOD, PostgreSQLParserPI, PostgreSQLParserPOWER, PostgreSQLParserRADIANS, PostgreSQLParserROUND, PostgreSQLParserSCALE, PostgreSQLParserSIGN, PostgreSQLParserSQRT, PostgreSQLParserTRIM_SCALE, PostgreSQLParserTRUNC, PostgreSQLParserWIDTH_BUCKET, PostgreSQLParserRANDOM, PostgreSQLParserSETSEED, PostgreSQLParserACOS, PostgreSQLParserACOSD, PostgreSQLParserASIN, PostgreSQLParserASIND, PostgreSQLParserATAN, PostgreSQLParserATAND, PostgreSQLParserATAN2, PostgreSQLParserATAN2D, PostgreSQLParserCOS, PostgreSQLParserCOSD, PostgreSQLParserCOT, PostgreSQLParserCOTD, PostgreSQLParserSIN, PostgreSQLParserSIND, PostgreSQLParserTAN, PostgreSQLParserTAND, PostgreSQLParserSINH, PostgreSQLParserCOSH, PostgreSQLParserTANH, PostgreSQLParserASINH, PostgreSQLParserACOSH, PostgreSQLParserATANH, PostgreSQLParserBIT_LENGTH, PostgreSQLParserCHAR_LENGTH, PostgreSQLParserCHARACTER_LENGTH, PostgreSQLParserLOWER, PostgreSQLParserOCTET_LENGTH, PostgreSQLParserUPPER, PostgreSQLParserASCII, PostgreSQLParserBTRIM, PostgreSQLParserCHR, PostgreSQLParserCONCAT, PostgreSQLParserCONCAT_WS, PostgreSQLParserFORMAT, PostgreSQLParserINITCAP, PostgreSQLParserLENGTH, PostgreSQLParserLPAD, PostgreSQLParserLTRIM, PostgreSQLParserMD5, PostgreSQLParserPARSE_IDENT, PostgreSQLParserPG_CLIENT_ENCODING, PostgreSQLParserQUOTE_IDENT, PostgreSQLParserQUOTE_LITERAL, PostgreSQLParserQUOTE_NULLABLE, PostgreSQLParserREGEXP_COUNT, PostgreSQLParserREGEXP_INSTR, PostgreSQLParserREGEXP_LIKE, PostgreSQLParserREGEXP_MATCH, PostgreSQLParserREGEXP_MATCHES, PostgreSQLParserREGEXP_REPLACE, PostgreSQLParserREGEXP_SPLIT_TO_ARRAY, PostgreSQLParserREGEXP_SPLIT_TO_TABLE, PostgreSQLParserREGEXP_SUBSTR, PostgreSQLParserREPEAT, PostgreSQLParserRPAD, PostgreSQLParserRTRIM, PostgreSQLParserSPLIT_PART, PostgreSQLParserSTARTS_WITH, PostgreSQLParserSTRING_TO_ARRAY, PostgreSQLParserSTRING_TO_TABLE, PostgreSQLParserSTRPOS, PostgreSQLParserSUBSTR, PostgreSQLParserTO_ASCII, PostgreSQLParserTO_HEX, PostgreSQLParserTRANSLATE, PostgreSQLParserUNISTR, PostgreSQLParserAGE, PostgreSQLParserCLOCK_TIMESTAMP, PostgreSQLParserDATE_BIN, PostgreSQLParserDATE_PART, PostgreSQLParserDATE_TRUNC, PostgreSQLParserISFINITE, PostgreSQLParserJUSTIFY_DAYS, PostgreSQLParserJUSTIFY_HOURS, PostgreSQLParserJUSTIFY_INTERVAL, PostgreSQLParserMAKE_DATE, PostgreSQLParserMAKE_INTERVAL, PostgreSQLParserMAKE_TIME, PostgreSQLParserMAKE_TIMESTAMP, PostgreSQLParserMAKE_TIMESTAMPTZ, PostgreSQLParserNOW, PostgreSQLParserSTATEMENT_TIMESTAMP, PostgreSQLParserTIMEOFDAY, PostgreSQLParserTRANSACTION_TIMESTAMP, PostgreSQLParserTO_TIMESTAMP, PostgreSQLParserTO_CHAR, PostgreSQLParserTO_DATE, PostgreSQLParserTO_NUMBER, PostgreSQLParserIdentifier, PostgreSQLParserQuotedIdentifier, PostgreSQLParserUnicodeQuotedIdentifier, PostgreSQLParserPLSQLVARIABLENAME, PostgreSQLParserPLSQLIDENTIFIER:
			{
				p.SetState(10606)
				p.Any_name()
			}

		case PostgreSQLParserALL:
			{
				p.SetState(10607)
				p.Match(PostgreSQLParserALL)
				if p.HasError() {
					// Recognition error - abort rule
					goto errorExit
				}
			}

		default:
			p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
			goto errorExit
		}
		{
			p.SetState(10610)
			p.Match(PostgreSQLParserSEMI)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	default:
		p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// ICursor_variableContext is an interface to support dynamic dispatch.
type ICursor_variableContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Colid() IColidContext
	PARAM() antlr.TerminalNode

	// IsCursor_variableContext differentiates from other interfaces.
	IsCursor_variableContext()
}

type Cursor_variableContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyCursor_variableContext() *Cursor_variableContext {
	var p = new(Cursor_variableContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_cursor_variable
	return p
}

func InitEmptyCursor_variableContext(p *Cursor_variableContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_cursor_variable
}

func (*Cursor_variableContext) IsCursor_variableContext() {}

func NewCursor_variableContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Cursor_variableContext {
	var p = new(Cursor_variableContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_cursor_variable

	return p
}

func (s *Cursor_variableContext) GetParser() antlr.Parser { return s.parser }

func (s *Cursor_variableContext) Colid() IColidContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IColidContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IColidContext)
}

func (s *Cursor_variableContext) PARAM() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserPARAM, 0)
}

func (s *Cursor_variableContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Cursor_variableContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Cursor_variableContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterCursor_variable(s)
	}
}

func (s *Cursor_variableContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitCursor_variable(s)
	}
}

func (s *Cursor_variableContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitCursor_variable(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Cursor_variable() (localctx ICursor_variableContext) {
	localctx = NewCursor_variableContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1586, PostgreSQLParserRULE_cursor_variable)
	p.SetState(10615)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetTokenStream().LA(1) {
	case PostgreSQLParserAND, PostgreSQLParserARRAY, PostgreSQLParserCOLLATE, PostgreSQLParserCOLUMN, PostgreSQLParserCONSTRAINT, PostgreSQLParserDEFAULT, PostgreSQLParserDO, PostgreSQLParserFETCH, PostgreSQLParserTABLE, PostgreSQLParserIS, PostgreSQLParserLEFT, PostgreSQLParserOUTER_P, PostgreSQLParserOVER, PostgreSQLParserRIGHT, PostgreSQLParserABORT_P, PostgreSQLParserABSOLUTE_P, PostgreSQLParserACCESS, PostgreSQLParserACTION, PostgreSQLParserADD_P, PostgreSQLParserADMIN, PostgreSQLParserAFTER, PostgreSQLParserAGGREGATE, PostgreSQLParserALSO, PostgreSQLParserALTER, PostgreSQLParserALWAYS, PostgreSQLParserASSERTION, PostgreSQLParserASSIGNMENT, PostgreSQLParserAT, PostgreSQLParserATTRIBUTE, PostgreSQLParserBACKWARD, PostgreSQLParserBEFORE, PostgreSQLParserBEGIN_P, PostgreSQLParserBY, PostgreSQLParserCACHE, PostgreSQLParserCALLED, PostgreSQLParserCASCADE, PostgreSQLParserCASCADED, PostgreSQLParserCATALOG, PostgreSQLParserCHAIN, PostgreSQLParserCHARACTERISTICS, PostgreSQLParserCHECKPOINT, PostgreSQLParserCLASS, PostgreSQLParserCLOSE, PostgreSQLParserCLUSTER, PostgreSQLParserCOMMENT, PostgreSQLParserCOMMENTS, PostgreSQLParserCOMMIT, PostgreSQLParserCOMMITTED, PostgreSQLParserCONFIGURATION, PostgreSQLParserCONNECTION, PostgreSQLParserCONSTRAINTS, PostgreSQLParserCONTENT_P, PostgreSQLParserCONTINUE_P, PostgreSQLParserCONVERSION_P, PostgreSQLParserCOPY, PostgreSQLParserCOST, PostgreSQLParserCSV, PostgreSQLParserCURSOR, PostgreSQLParserCYCLE, PostgreSQLParserDATA_P, PostgreSQLParserDATABASE, PostgreSQLParserDAY_P, PostgreSQLParserDEALLOCATE, PostgreSQLParserDECLARE, PostgreSQLParserDEFAULTS, PostgreSQLParserDEFERRED, PostgreSQLParserDEFINER, PostgreSQLParserDELETE_P, PostgreSQLParserDELIMITER, PostgreSQLParserDELIMITERS, PostgreSQLParserDICTIONARY, PostgreSQLParserDISABLE_P, PostgreSQLParserDISCARD, PostgreSQLParserDOCUMENT_P, PostgreSQLParserDOMAIN_P, PostgreSQLParserDOUBLE_P, PostgreSQLParserDROP, PostgreSQLParserEACH, PostgreSQLParserENABLE_P, PostgreSQLParserENCODING, PostgreSQLParserENCRYPTED, PostgreSQLParserENUM_P, PostgreSQLParserESCAPE, PostgreSQLParserEVENT, PostgreSQLParserEXCLUDE, PostgreSQLParserEXCLUDING, PostgreSQLParserEXCLUSIVE, PostgreSQLParserEXECUTE, PostgreSQLParserEXPLAIN, PostgreSQLParserEXTENSION, PostgreSQLParserEXTERNAL, PostgreSQLParserFAMILY, PostgreSQLParserFIRST_P, PostgreSQLParserFOLLOWING, PostgreSQLParserFORCE, PostgreSQLParserFORWARD, PostgreSQLParserFUNCTION, PostgreSQLParserFUNCTIONS, PostgreSQLParserGLOBAL, PostgreSQLParserGRANTED, PostgreSQLParserHANDLER, PostgreSQLParserHEADER_P, PostgreSQLParserHOLD, PostgreSQLParserHOUR_P, PostgreSQLParserIDENTITY_P, PostgreSQLParserIF_P, PostgreSQLParserIMMEDIATE, PostgreSQLParserIMMUTABLE, PostgreSQLParserIMPLICIT_P, PostgreSQLParserINCLUDING, PostgreSQLParserINCREMENT, PostgreSQLParserINDEX, PostgreSQLParserINDEXES, PostgreSQLParserINHERIT, PostgreSQLParserINHERITS, PostgreSQLParserINLINE_P, PostgreSQLParserINSENSITIVE, PostgreSQLParserINSERT, PostgreSQLParserINSTEAD, PostgreSQLParserINVOKER, PostgreSQLParserISOLATION, PostgreSQLParserKEY, PostgreSQLParserLABEL, PostgreSQLParserLANGUAGE, PostgreSQLParserLARGE_P, PostgreSQLParserLAST_P, PostgreSQLParserLEAKPROOF, PostgreSQLParserLEVEL, PostgreSQLParserLISTEN, PostgreSQLParserLOAD, PostgreSQLParserLOCAL, PostgreSQLParserLOCATION, PostgreSQLParserLOCK_P, PostgreSQLParserMAPPING, PostgreSQLParserMATCH, PostgreSQLParserMATERIALIZED, PostgreSQLParserMAXVALUE, PostgreSQLParserMINUTE_P, PostgreSQLParserMINVALUE, PostgreSQLParserMODE, PostgreSQLParserMONTH_P, PostgreSQLParserMOVE, PostgreSQLParserNAME_P, PostgreSQLParserNAMES, PostgreSQLParserNEXT, PostgreSQLParserNO, PostgreSQLParserNOTHING, PostgreSQLParserNOTIFY, PostgreSQLParserNOWAIT, PostgreSQLParserNULLS_P, PostgreSQLParserOBJECT_P, PostgreSQLParserOF, PostgreSQLParserOFF, PostgreSQLParserOIDS, PostgreSQLParserOPERATOR, PostgreSQLParserOPTION, PostgreSQLParserOPTIONS, PostgreSQLParserOWNED, PostgreSQLParserOWNER, PostgreSQLParserPARSER, PostgreSQLParserPARTIAL, PostgreSQLParserPARTITION, PostgreSQLParserPASSING, PostgreSQLParserPASSWORD, PostgreSQLParserPLANS, PostgreSQLParserPRECEDING, PostgreSQLParserPREPARE, PostgreSQLParserPREPARED, PostgreSQLParserPRESERVE, PostgreSQLParserPRIOR, PostgreSQLParserPRIVILEGES, PostgreSQLParserPROCEDURAL, PostgreSQLParserPROCEDURE, PostgreSQLParserPROGRAM, PostgreSQLParserQUOTE, PostgreSQLParserRANGE, PostgreSQLParserREAD, PostgreSQLParserREASSIGN, PostgreSQLParserRECHECK, PostgreSQLParserRECURSIVE, PostgreSQLParserREF, PostgreSQLParserREFRESH, PostgreSQLParserREINDEX, PostgreSQLParserRELATIVE_P, PostgreSQLParserRELEASE, PostgreSQLParserRENAME, PostgreSQLParserREPEATABLE, PostgreSQLParserREPLACE, PostgreSQLParserREPLICA, PostgreSQLParserRESET, PostgreSQLParserRESTART, PostgreSQLParserRESTRICT, PostgreSQLParserRETURNS, PostgreSQLParserREVOKE, PostgreSQLParserROLE, PostgreSQLParserROLLBACK, PostgreSQLParserROWS, PostgreSQLParserRULE, PostgreSQLParserSAVEPOINT, PostgreSQLParserSCHEMA, PostgreSQLParserSCROLL, PostgreSQLParserSEARCH, PostgreSQLParserSECOND_P, PostgreSQLParserSECURITY, PostgreSQLParserSEQUENCE, PostgreSQLParserSEQUENCES, PostgreSQLParserSERIALIZABLE, PostgreSQLParserSERVER, PostgreSQLParserSESSION, PostgreSQLParserSET, PostgreSQLParserSHARE, PostgreSQLParserSHOW, PostgreSQLParserSIMPLE, PostgreSQLParserSNAPSHOT, PostgreSQLParserSTABLE, PostgreSQLParserSTANDALONE_P, PostgreSQLParserSTART, PostgreSQLParserSTATEMENT, PostgreSQLParserSTATISTICS, PostgreSQLParserSTDIN, PostgreSQLParserSTDOUT, PostgreSQLParserSTORAGE, PostgreSQLParserSTRICT_P, PostgreSQLParserSTRIP_P, PostgreSQLParserSYSID, PostgreSQLParserSYSTEM_P, PostgreSQLParserTABLES, PostgreSQLParserTABLESPACE, PostgreSQLParserTEMP, PostgreSQLParserTEMPLATE, PostgreSQLParserTEMPORARY, PostgreSQLParserTEXT_P, PostgreSQLParserTRANSACTION, PostgreSQLParserTRIGGER, PostgreSQLParserTRUNCATE, PostgreSQLParserTRUSTED, PostgreSQLParserTYPE_P, PostgreSQLParserTYPES_P, PostgreSQLParserUNBOUNDED, PostgreSQLParserUNCOMMITTED, PostgreSQLParserUNENCRYPTED, PostgreSQLParserUNKNOWN, PostgreSQLParserUNLISTEN, PostgreSQLParserUNLOGGED, PostgreSQLParserUNTIL, PostgreSQLParserUPDATE, PostgreSQLParserVACUUM, PostgreSQLParserVALID, PostgreSQLParserVALIDATE, PostgreSQLParserVALIDATOR, PostgreSQLParserVARYING, PostgreSQLParserVERSION_P, PostgreSQLParserVIEW, PostgreSQLParserVOLATILE, PostgreSQLParserWHITESPACE_P, PostgreSQLParserWITHOUT, PostgreSQLParserWORK, PostgreSQLParserWRAPPER, PostgreSQLParserWRITE, PostgreSQLParserXML_P, PostgreSQLParserYEAR_P, PostgreSQLParserYES_P, PostgreSQLParserZONE, PostgreSQLParserBETWEEN, PostgreSQLParserBIGINT, PostgreSQLParserBIT, PostgreSQLParserBOOLEAN_P, PostgreSQLParserCHAR_P, PostgreSQLParserCHARACTER, PostgreSQLParserCOALESCE, PostgreSQLParserDEC, PostgreSQLParserDECIMAL_P, PostgreSQLParserEXISTS, PostgreSQLParserEXTRACT, PostgreSQLParserFLOAT_P, PostgreSQLParserGREATEST, PostgreSQLParserINOUT, PostgreSQLParserINT_P, PostgreSQLParserINTEGER, PostgreSQLParserINTERVAL, PostgreSQLParserLEAST, PostgreSQLParserNATIONAL, PostgreSQLParserNCHAR, PostgreSQLParserNONE, PostgreSQLParserNULLIF, PostgreSQLParserNUMERIC, PostgreSQLParserOVERLAY, PostgreSQLParserPOSITION, PostgreSQLParserPRECISION, PostgreSQLParserREAL, PostgreSQLParserROW, PostgreSQLParserSETOF, PostgreSQLParserSMALLINT, PostgreSQLParserSUBSTRING, PostgreSQLParserTIME, PostgreSQLParserTIMESTAMP, PostgreSQLParserTREAT, PostgreSQLParserTRIM, PostgreSQLParserVALUES, PostgreSQLParserVARCHAR, PostgreSQLParserXMLATTRIBUTES, PostgreSQLParserXMLCOMMENT, PostgreSQLParserXMLAGG, PostgreSQLParserXML_IS_WELL_FORMED, PostgreSQLParserXML_IS_WELL_FORMED_DOCUMENT, PostgreSQLParserXML_IS_WELL_FORMED_CONTENT, PostgreSQLParserXPATH, PostgreSQLParserXPATH_EXISTS, PostgreSQLParserXMLCONCAT, PostgreSQLParserXMLELEMENT, PostgreSQLParserXMLEXISTS, PostgreSQLParserXMLFOREST, PostgreSQLParserXMLPARSE, PostgreSQLParserXMLPI, PostgreSQLParserXMLROOT, PostgreSQLParserXMLSERIALIZE, PostgreSQLParserCALL, PostgreSQLParserCURRENT_P, PostgreSQLParserATTACH, PostgreSQLParserDETACH, PostgreSQLParserEXPRESSION, PostgreSQLParserGENERATED, PostgreSQLParserLOGGED, PostgreSQLParserSTORED, PostgreSQLParserINCLUDE, PostgreSQLParserROUTINE, PostgreSQLParserTRANSFORM, PostgreSQLParserIMPORT_P, PostgreSQLParserPOLICY, PostgreSQLParserMETHOD, PostgreSQLParserREFERENCING, PostgreSQLParserNEW, PostgreSQLParserOLD, PostgreSQLParserVALUE_P, PostgreSQLParserSUBSCRIPTION, PostgreSQLParserPUBLICATION, PostgreSQLParserOUT_P, PostgreSQLParserROUTINES, PostgreSQLParserSCHEMAS, PostgreSQLParserPROCEDURES, PostgreSQLParserINPUT_P, PostgreSQLParserSUPPORT, PostgreSQLParserPARALLEL, PostgreSQLParserSQL_P, PostgreSQLParserDEPENDS, PostgreSQLParserOVERRIDING, PostgreSQLParserCONFLICT, PostgreSQLParserSKIP_P, PostgreSQLParserLOCKED, PostgreSQLParserTIES, PostgreSQLParserROLLUP, PostgreSQLParserCUBE, PostgreSQLParserGROUPING, PostgreSQLParserSETS, PostgreSQLParserORDINALITY, PostgreSQLParserXMLTABLE, PostgreSQLParserCOLUMNS, PostgreSQLParserXMLNAMESPACES, PostgreSQLParserROWTYPE, PostgreSQLParserNORMALIZED, PostgreSQLParserWITHIN, PostgreSQLParserFILTER, PostgreSQLParserGROUPS, PostgreSQLParserOTHERS, PostgreSQLParserNFC, PostgreSQLParserNFD, PostgreSQLParserNFKC, PostgreSQLParserNFKD, PostgreSQLParserUESCAPE, PostgreSQLParserVIEWS, PostgreSQLParserNORMALIZE, PostgreSQLParserDUMP, PostgreSQLParserPRINT_STRICT_PARAMS, PostgreSQLParserVARIABLE_CONFLICT, PostgreSQLParserERROR, PostgreSQLParserUSE_VARIABLE, PostgreSQLParserUSE_COLUMN, PostgreSQLParserALIAS, PostgreSQLParserCONSTANT, PostgreSQLParserPERFORM, PostgreSQLParserGET, PostgreSQLParserDIAGNOSTICS, PostgreSQLParserSTACKED, PostgreSQLParserELSIF, PostgreSQLParserREVERSE, PostgreSQLParserSLICE, PostgreSQLParserEXIT, PostgreSQLParserRETURN, PostgreSQLParserQUERY, PostgreSQLParserRAISE, PostgreSQLParserSQLSTATE, PostgreSQLParserDEBUG, PostgreSQLParserLOG, PostgreSQLParserINFO, PostgreSQLParserNOTICE, PostgreSQLParserWARNING, PostgreSQLParserEXCEPTION, PostgreSQLParserASSERT, PostgreSQLParserOPEN, PostgreSQLParserABS, PostgreSQLParserCBRT, PostgreSQLParserCEIL, PostgreSQLParserCEILING, PostgreSQLParserDEGREES, PostgreSQLParserDIV, PostgreSQLParserEXP, PostgreSQLParserFACTORIAL, PostgreSQLParserFLOOR, PostgreSQLParserGCD, PostgreSQLParserLCM, PostgreSQLParserLN, PostgreSQLParserLOG10, PostgreSQLParserMIN_SCALE, PostgreSQLParserMOD, PostgreSQLParserPI, PostgreSQLParserPOWER, PostgreSQLParserRADIANS, PostgreSQLParserROUND, PostgreSQLParserSCALE, PostgreSQLParserSIGN, PostgreSQLParserSQRT, PostgreSQLParserTRIM_SCALE, PostgreSQLParserTRUNC, PostgreSQLParserWIDTH_BUCKET, PostgreSQLParserRANDOM, PostgreSQLParserSETSEED, PostgreSQLParserACOS, PostgreSQLParserACOSD, PostgreSQLParserASIN, PostgreSQLParserASIND, PostgreSQLParserATAN, PostgreSQLParserATAND, PostgreSQLParserATAN2, PostgreSQLParserATAN2D, PostgreSQLParserCOS, PostgreSQLParserCOSD, PostgreSQLParserCOT, PostgreSQLParserCOTD, PostgreSQLParserSIN, PostgreSQLParserSIND, PostgreSQLParserTAN, PostgreSQLParserTAND, PostgreSQLParserSINH, PostgreSQLParserCOSH, PostgreSQLParserTANH, PostgreSQLParserASINH, PostgreSQLParserACOSH, PostgreSQLParserATANH, PostgreSQLParserBIT_LENGTH, PostgreSQLParserCHAR_LENGTH, PostgreSQLParserCHARACTER_LENGTH, PostgreSQLParserLOWER, PostgreSQLParserOCTET_LENGTH, PostgreSQLParserUPPER, PostgreSQLParserASCII, PostgreSQLParserBTRIM, PostgreSQLParserCHR, PostgreSQLParserCONCAT, PostgreSQLParserCONCAT_WS, PostgreSQLParserFORMAT, PostgreSQLParserINITCAP, PostgreSQLParserLENGTH, PostgreSQLParserLPAD, PostgreSQLParserLTRIM, PostgreSQLParserMD5, PostgreSQLParserPARSE_IDENT, PostgreSQLParserPG_CLIENT_ENCODING, PostgreSQLParserQUOTE_IDENT, PostgreSQLParserQUOTE_LITERAL, PostgreSQLParserQUOTE_NULLABLE, PostgreSQLParserREGEXP_COUNT, PostgreSQLParserREGEXP_INSTR, PostgreSQLParserREGEXP_LIKE, PostgreSQLParserREGEXP_MATCH, PostgreSQLParserREGEXP_MATCHES, PostgreSQLParserREGEXP_REPLACE, PostgreSQLParserREGEXP_SPLIT_TO_ARRAY, PostgreSQLParserREGEXP_SPLIT_TO_TABLE, PostgreSQLParserREGEXP_SUBSTR, PostgreSQLParserREPEAT, PostgreSQLParserRPAD, PostgreSQLParserRTRIM, PostgreSQLParserSPLIT_PART, PostgreSQLParserSTARTS_WITH, PostgreSQLParserSTRING_TO_ARRAY, PostgreSQLParserSTRING_TO_TABLE, PostgreSQLParserSTRPOS, PostgreSQLParserSUBSTR, PostgreSQLParserTO_ASCII, PostgreSQLParserTO_HEX, PostgreSQLParserTRANSLATE, PostgreSQLParserUNISTR, PostgreSQLParserAGE, PostgreSQLParserCLOCK_TIMESTAMP, PostgreSQLParserDATE_BIN, PostgreSQLParserDATE_PART, PostgreSQLParserDATE_TRUNC, PostgreSQLParserISFINITE, PostgreSQLParserJUSTIFY_DAYS, PostgreSQLParserJUSTIFY_HOURS, PostgreSQLParserJUSTIFY_INTERVAL, PostgreSQLParserMAKE_DATE, PostgreSQLParserMAKE_INTERVAL, PostgreSQLParserMAKE_TIME, PostgreSQLParserMAKE_TIMESTAMP, PostgreSQLParserMAKE_TIMESTAMPTZ, PostgreSQLParserNOW, PostgreSQLParserSTATEMENT_TIMESTAMP, PostgreSQLParserTIMEOFDAY, PostgreSQLParserTRANSACTION_TIMESTAMP, PostgreSQLParserTO_TIMESTAMP, PostgreSQLParserTO_CHAR, PostgreSQLParserTO_DATE, PostgreSQLParserTO_NUMBER, PostgreSQLParserIdentifier, PostgreSQLParserQuotedIdentifier, PostgreSQLParserUnicodeQuotedIdentifier, PostgreSQLParserPLSQLVARIABLENAME, PostgreSQLParserPLSQLIDENTIFIER:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(10613)
			p.Colid()
		}

	case PostgreSQLParserPARAM:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(10614)
			p.Match(PostgreSQLParserPARAM)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}

	default:
		p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IException_sectContext is an interface to support dynamic dispatch.
type IException_sectContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	EXCEPTION() antlr.TerminalNode
	Proc_exceptions() IProc_exceptionsContext

	// IsException_sectContext differentiates from other interfaces.
	IsException_sectContext()
}

type Exception_sectContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyException_sectContext() *Exception_sectContext {
	var p = new(Exception_sectContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_exception_sect
	return p
}

func InitEmptyException_sectContext(p *Exception_sectContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_exception_sect
}

func (*Exception_sectContext) IsException_sectContext() {}

func NewException_sectContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Exception_sectContext {
	var p = new(Exception_sectContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_exception_sect

	return p
}

func (s *Exception_sectContext) GetParser() antlr.Parser { return s.parser }

func (s *Exception_sectContext) EXCEPTION() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserEXCEPTION, 0)
}

func (s *Exception_sectContext) Proc_exceptions() IProc_exceptionsContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IProc_exceptionsContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IProc_exceptionsContext)
}

func (s *Exception_sectContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Exception_sectContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Exception_sectContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterException_sect(s)
	}
}

func (s *Exception_sectContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitException_sect(s)
	}
}

func (s *Exception_sectContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitException_sect(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Exception_sect() (localctx IException_sectContext) {
	localctx = NewException_sectContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1588, PostgreSQLParserRULE_exception_sect)
	p.SetState(10620)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetTokenStream().LA(1) {
	case PostgreSQLParserEND_P:
		p.EnterOuterAlt(localctx, 1)

	case PostgreSQLParserEXCEPTION:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(10618)
			p.Match(PostgreSQLParserEXCEPTION)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(10619)
			p.Proc_exceptions()
		}

	default:
		p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IProc_exceptionsContext is an interface to support dynamic dispatch.
type IProc_exceptionsContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	AllProc_exception() []IProc_exceptionContext
	Proc_exception(i int) IProc_exceptionContext

	// IsProc_exceptionsContext differentiates from other interfaces.
	IsProc_exceptionsContext()
}

type Proc_exceptionsContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyProc_exceptionsContext() *Proc_exceptionsContext {
	var p = new(Proc_exceptionsContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_proc_exceptions
	return p
}

func InitEmptyProc_exceptionsContext(p *Proc_exceptionsContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_proc_exceptions
}

func (*Proc_exceptionsContext) IsProc_exceptionsContext() {}

func NewProc_exceptionsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Proc_exceptionsContext {
	var p = new(Proc_exceptionsContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_proc_exceptions

	return p
}

func (s *Proc_exceptionsContext) GetParser() antlr.Parser { return s.parser }

func (s *Proc_exceptionsContext) AllProc_exception() []IProc_exceptionContext {
	children := s.GetChildren()
	len := 0
	for _, ctx := range children {
		if _, ok := ctx.(IProc_exceptionContext); ok {
			len++
		}
	}

	tst := make([]IProc_exceptionContext, len)
	i := 0
	for _, ctx := range children {
		if t, ok := ctx.(IProc_exceptionContext); ok {
			tst[i] = t.(IProc_exceptionContext)
			i++
		}
	}

	return tst
}

func (s *Proc_exceptionsContext) Proc_exception(i int) IProc_exceptionContext {
	var t antlr.RuleContext
	j := 0
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IProc_exceptionContext); ok {
			if j == i {
				t = ctx.(antlr.RuleContext)
				break
			}
			j++
		}
	}

	if t == nil {
		return nil
	}

	return t.(IProc_exceptionContext)
}

func (s *Proc_exceptionsContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Proc_exceptionsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Proc_exceptionsContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterProc_exceptions(s)
	}
}

func (s *Proc_exceptionsContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitProc_exceptions(s)
	}
}

func (s *Proc_exceptionsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitProc_exceptions(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Proc_exceptions() (localctx IProc_exceptionsContext) {
	localctx = NewProc_exceptionsContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1590, PostgreSQLParserRULE_proc_exceptions)
	var _la int

	p.EnterOuterAlt(localctx, 1)
	p.SetState(10623)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}
	_la = p.GetTokenStream().LA(1)

	for ok := true; ok; ok = _la == PostgreSQLParserWHEN {
		{
			p.SetState(10622)
			p.Proc_exception()
		}

		p.SetState(10625)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}
		_la = p.GetTokenStream().LA(1)
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IProc_exceptionContext is an interface to support dynamic dispatch.
type IProc_exceptionContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	WHEN() antlr.TerminalNode
	Proc_conditions() IProc_conditionsContext
	THEN() antlr.TerminalNode
	Proc_sect() IProc_sectContext

	// IsProc_exceptionContext differentiates from other interfaces.
	IsProc_exceptionContext()
}

type Proc_exceptionContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyProc_exceptionContext() *Proc_exceptionContext {
	var p = new(Proc_exceptionContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_proc_exception
	return p
}

func InitEmptyProc_exceptionContext(p *Proc_exceptionContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_proc_exception
}

func (*Proc_exceptionContext) IsProc_exceptionContext() {}

func NewProc_exceptionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Proc_exceptionContext {
	var p = new(Proc_exceptionContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_proc_exception

	return p
}

func (s *Proc_exceptionContext) GetParser() antlr.Parser { return s.parser }

func (s *Proc_exceptionContext) WHEN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserWHEN, 0)
}

func (s *Proc_exceptionContext) Proc_conditions() IProc_conditionsContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IProc_conditionsContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IProc_conditionsContext)
}

func (s *Proc_exceptionContext) THEN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserTHEN, 0)
}

func (s *Proc_exceptionContext) Proc_sect() IProc_sectContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IProc_sectContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IProc_sectContext)
}

func (s *Proc_exceptionContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Proc_exceptionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Proc_exceptionContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterProc_exception(s)
	}
}

func (s *Proc_exceptionContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitProc_exception(s)
	}
}

func (s *Proc_exceptionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitProc_exception(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Proc_exception() (localctx IProc_exceptionContext) {
	localctx = NewProc_exceptionContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1592, PostgreSQLParserRULE_proc_exception)
	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(10627)
		p.Match(PostgreSQLParserWHEN)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(10628)
		p.Proc_conditions()
	}
	{
		p.SetState(10629)
		p.Match(PostgreSQLParserTHEN)
		if p.HasError() {
			// Recognition error - abort rule
			goto errorExit
		}
	}
	{
		p.SetState(10630)
		p.Proc_sect()
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IProc_conditionsContext is an interface to support dynamic dispatch.
type IProc_conditionsContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	AllProc_condition() []IProc_conditionContext
	Proc_condition(i int) IProc_conditionContext
	AllOR() []antlr.TerminalNode
	OR(i int) antlr.TerminalNode

	// IsProc_conditionsContext differentiates from other interfaces.
	IsProc_conditionsContext()
}

type Proc_conditionsContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyProc_conditionsContext() *Proc_conditionsContext {
	var p = new(Proc_conditionsContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_proc_conditions
	return p
}

func InitEmptyProc_conditionsContext(p *Proc_conditionsContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_proc_conditions
}

func (*Proc_conditionsContext) IsProc_conditionsContext() {}

func NewProc_conditionsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Proc_conditionsContext {
	var p = new(Proc_conditionsContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_proc_conditions

	return p
}

func (s *Proc_conditionsContext) GetParser() antlr.Parser { return s.parser }

func (s *Proc_conditionsContext) AllProc_condition() []IProc_conditionContext {
	children := s.GetChildren()
	len := 0
	for _, ctx := range children {
		if _, ok := ctx.(IProc_conditionContext); ok {
			len++
		}
	}

	tst := make([]IProc_conditionContext, len)
	i := 0
	for _, ctx := range children {
		if t, ok := ctx.(IProc_conditionContext); ok {
			tst[i] = t.(IProc_conditionContext)
			i++
		}
	}

	return tst
}

func (s *Proc_conditionsContext) Proc_condition(i int) IProc_conditionContext {
	var t antlr.RuleContext
	j := 0
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IProc_conditionContext); ok {
			if j == i {
				t = ctx.(antlr.RuleContext)
				break
			}
			j++
		}
	}

	if t == nil {
		return nil
	}

	return t.(IProc_conditionContext)
}

func (s *Proc_conditionsContext) AllOR() []antlr.TerminalNode {
	return s.GetTokens(PostgreSQLParserOR)
}

func (s *Proc_conditionsContext) OR(i int) antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserOR, i)
}

func (s *Proc_conditionsContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Proc_conditionsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Proc_conditionsContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterProc_conditions(s)
	}
}

func (s *Proc_conditionsContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitProc_conditions(s)
	}
}

func (s *Proc_conditionsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitProc_conditions(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Proc_conditions() (localctx IProc_conditionsContext) {
	localctx = NewProc_conditionsContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1594, PostgreSQLParserRULE_proc_conditions)
	var _la int

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(10632)
		p.Proc_condition()
	}
	p.SetState(10637)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}
	_la = p.GetTokenStream().LA(1)

	for _la == PostgreSQLParserOR {
		{
			p.SetState(10633)
			p.Match(PostgreSQLParserOR)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(10634)
			p.Proc_condition()
		}

		p.SetState(10639)
		p.GetErrorHandler().Sync(p)
		if p.HasError() {
			goto errorExit
		}
		_la = p.GetTokenStream().LA(1)
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IProc_conditionContext is an interface to support dynamic dispatch.
type IProc_conditionContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Any_identifier() IAny_identifierContext
	SQLSTATE() antlr.TerminalNode
	Sconst() ISconstContext

	// IsProc_conditionContext differentiates from other interfaces.
	IsProc_conditionContext()
}

type Proc_conditionContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyProc_conditionContext() *Proc_conditionContext {
	var p = new(Proc_conditionContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_proc_condition
	return p
}

func InitEmptyProc_conditionContext(p *Proc_conditionContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_proc_condition
}

func (*Proc_conditionContext) IsProc_conditionContext() {}

func NewProc_conditionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Proc_conditionContext {
	var p = new(Proc_conditionContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_proc_condition

	return p
}

func (s *Proc_conditionContext) GetParser() antlr.Parser { return s.parser }

func (s *Proc_conditionContext) Any_identifier() IAny_identifierContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IAny_identifierContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IAny_identifierContext)
}

func (s *Proc_conditionContext) SQLSTATE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserSQLSTATE, 0)
}

func (s *Proc_conditionContext) Sconst() ISconstContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ISconstContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ISconstContext)
}

func (s *Proc_conditionContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Proc_conditionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Proc_conditionContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterProc_condition(s)
	}
}

func (s *Proc_conditionContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitProc_condition(s)
	}
}

func (s *Proc_conditionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitProc_condition(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Proc_condition() (localctx IProc_conditionContext) {
	localctx = NewProc_conditionContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1596, PostgreSQLParserRULE_proc_condition)
	p.SetState(10643)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 737, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(10640)
			p.Any_identifier()
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(10641)
			p.Match(PostgreSQLParserSQLSTATE)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(10642)
			p.Sconst()
		}

	case antlr.ATNInvalidAltNumber:
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IOpt_block_labelContext is an interface to support dynamic dispatch.
type IOpt_block_labelContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Label_decl() ILabel_declContext

	// IsOpt_block_labelContext differentiates from other interfaces.
	IsOpt_block_labelContext()
}

type Opt_block_labelContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyOpt_block_labelContext() *Opt_block_labelContext {
	var p = new(Opt_block_labelContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opt_block_label
	return p
}

func InitEmptyOpt_block_labelContext(p *Opt_block_labelContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opt_block_label
}

func (*Opt_block_labelContext) IsOpt_block_labelContext() {}

func NewOpt_block_labelContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_block_labelContext {
	var p = new(Opt_block_labelContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_opt_block_label

	return p
}

func (s *Opt_block_labelContext) GetParser() antlr.Parser { return s.parser }

func (s *Opt_block_labelContext) Label_decl() ILabel_declContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ILabel_declContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ILabel_declContext)
}

func (s *Opt_block_labelContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Opt_block_labelContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Opt_block_labelContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterOpt_block_label(s)
	}
}

func (s *Opt_block_labelContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitOpt_block_label(s)
	}
}

func (s *Opt_block_labelContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitOpt_block_label(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Opt_block_label() (localctx IOpt_block_labelContext) {
	localctx = NewOpt_block_labelContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1598, PostgreSQLParserRULE_opt_block_label)
	p.SetState(10647)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetTokenStream().LA(1) {
	case PostgreSQLParserBEGIN_P, PostgreSQLParserDECLARE:
		p.EnterOuterAlt(localctx, 1)

	case PostgreSQLParserLESS_LESS:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(10646)
			p.Label_decl()
		}

	default:
		p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IOpt_loop_labelContext is an interface to support dynamic dispatch.
type IOpt_loop_labelContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Label_decl() ILabel_declContext

	// IsOpt_loop_labelContext differentiates from other interfaces.
	IsOpt_loop_labelContext()
}

type Opt_loop_labelContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyOpt_loop_labelContext() *Opt_loop_labelContext {
	var p = new(Opt_loop_labelContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opt_loop_label
	return p
}

func InitEmptyOpt_loop_labelContext(p *Opt_loop_labelContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opt_loop_label
}

func (*Opt_loop_labelContext) IsOpt_loop_labelContext() {}

func NewOpt_loop_labelContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_loop_labelContext {
	var p = new(Opt_loop_labelContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_opt_loop_label

	return p
}

func (s *Opt_loop_labelContext) GetParser() antlr.Parser { return s.parser }

func (s *Opt_loop_labelContext) Label_decl() ILabel_declContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ILabel_declContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ILabel_declContext)
}

func (s *Opt_loop_labelContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Opt_loop_labelContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Opt_loop_labelContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterOpt_loop_label(s)
	}
}

func (s *Opt_loop_labelContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitOpt_loop_label(s)
	}
}

func (s *Opt_loop_labelContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitOpt_loop_label(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Opt_loop_label() (localctx IOpt_loop_labelContext) {
	localctx = NewOpt_loop_labelContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1600, PostgreSQLParserRULE_opt_loop_label)
	p.SetState(10651)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetTokenStream().LA(1) {
	case PostgreSQLParserFOR, PostgreSQLParserWHILE, PostgreSQLParserFOREACH, PostgreSQLParserLOOP:
		p.EnterOuterAlt(localctx, 1)

	case PostgreSQLParserLESS_LESS:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(10650)
			p.Label_decl()
		}

	default:
		p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IOpt_labelContext is an interface to support dynamic dispatch.
type IOpt_labelContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Any_identifier() IAny_identifierContext

	// IsOpt_labelContext differentiates from other interfaces.
	IsOpt_labelContext()
}

type Opt_labelContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyOpt_labelContext() *Opt_labelContext {
	var p = new(Opt_labelContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opt_label
	return p
}

func InitEmptyOpt_labelContext(p *Opt_labelContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opt_label
}

func (*Opt_labelContext) IsOpt_labelContext() {}

func NewOpt_labelContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_labelContext {
	var p = new(Opt_labelContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_opt_label

	return p
}

func (s *Opt_labelContext) GetParser() antlr.Parser { return s.parser }

func (s *Opt_labelContext) Any_identifier() IAny_identifierContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IAny_identifierContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IAny_identifierContext)
}

func (s *Opt_labelContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Opt_labelContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Opt_labelContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterOpt_label(s)
	}
}

func (s *Opt_labelContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitOpt_label(s)
	}
}

func (s *Opt_labelContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitOpt_label(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Opt_label() (localctx IOpt_labelContext) {
	localctx = NewOpt_labelContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1602, PostgreSQLParserRULE_opt_label)
	p.SetState(10655)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetTokenStream().LA(1) {
	case PostgreSQLParserEOF, PostgreSQLParserSEMI, PostgreSQLParserWHEN:
		p.EnterOuterAlt(localctx, 1)

	case PostgreSQLParserAND, PostgreSQLParserARRAY, PostgreSQLParserCOLLATE, PostgreSQLParserCOLUMN, PostgreSQLParserCONSTRAINT, PostgreSQLParserDEFAULT, PostgreSQLParserDO, PostgreSQLParserFETCH, PostgreSQLParserTABLE, PostgreSQLParserIS, PostgreSQLParserLEFT, PostgreSQLParserOUTER_P, PostgreSQLParserOVER, PostgreSQLParserRIGHT, PostgreSQLParserABORT_P, PostgreSQLParserABSOLUTE_P, PostgreSQLParserACCESS, PostgreSQLParserACTION, PostgreSQLParserADD_P, PostgreSQLParserADMIN, PostgreSQLParserAFTER, PostgreSQLParserAGGREGATE, PostgreSQLParserALSO, PostgreSQLParserALTER, PostgreSQLParserALWAYS, PostgreSQLParserASSERTION, PostgreSQLParserASSIGNMENT, PostgreSQLParserAT, PostgreSQLParserATTRIBUTE, PostgreSQLParserBACKWARD, PostgreSQLParserBEFORE, PostgreSQLParserBEGIN_P, PostgreSQLParserBY, PostgreSQLParserCACHE, PostgreSQLParserCALLED, PostgreSQLParserCASCADE, PostgreSQLParserCASCADED, PostgreSQLParserCATALOG, PostgreSQLParserCHAIN, PostgreSQLParserCHARACTERISTICS, PostgreSQLParserCHECKPOINT, PostgreSQLParserCLASS, PostgreSQLParserCLOSE, PostgreSQLParserCLUSTER, PostgreSQLParserCOMMENT, PostgreSQLParserCOMMENTS, PostgreSQLParserCOMMIT, PostgreSQLParserCOMMITTED, PostgreSQLParserCONFIGURATION, PostgreSQLParserCONNECTION, PostgreSQLParserCONSTRAINTS, PostgreSQLParserCONTENT_P, PostgreSQLParserCONTINUE_P, PostgreSQLParserCONVERSION_P, PostgreSQLParserCOPY, PostgreSQLParserCOST, PostgreSQLParserCSV, PostgreSQLParserCURSOR, PostgreSQLParserCYCLE, PostgreSQLParserDATA_P, PostgreSQLParserDATABASE, PostgreSQLParserDAY_P, PostgreSQLParserDEALLOCATE, PostgreSQLParserDECLARE, PostgreSQLParserDEFAULTS, PostgreSQLParserDEFERRED, PostgreSQLParserDEFINER, PostgreSQLParserDELETE_P, PostgreSQLParserDELIMITER, PostgreSQLParserDELIMITERS, PostgreSQLParserDICTIONARY, PostgreSQLParserDISABLE_P, PostgreSQLParserDISCARD, PostgreSQLParserDOCUMENT_P, PostgreSQLParserDOMAIN_P, PostgreSQLParserDOUBLE_P, PostgreSQLParserDROP, PostgreSQLParserEACH, PostgreSQLParserENABLE_P, PostgreSQLParserENCODING, PostgreSQLParserENCRYPTED, PostgreSQLParserENUM_P, PostgreSQLParserESCAPE, PostgreSQLParserEVENT, PostgreSQLParserEXCLUDE, PostgreSQLParserEXCLUDING, PostgreSQLParserEXCLUSIVE, PostgreSQLParserEXECUTE, PostgreSQLParserEXPLAIN, PostgreSQLParserEXTENSION, PostgreSQLParserEXTERNAL, PostgreSQLParserFAMILY, PostgreSQLParserFIRST_P, PostgreSQLParserFOLLOWING, PostgreSQLParserFORCE, PostgreSQLParserFORWARD, PostgreSQLParserFUNCTION, PostgreSQLParserFUNCTIONS, PostgreSQLParserGLOBAL, PostgreSQLParserGRANTED, PostgreSQLParserHANDLER, PostgreSQLParserHEADER_P, PostgreSQLParserHOLD, PostgreSQLParserHOUR_P, PostgreSQLParserIDENTITY_P, PostgreSQLParserIF_P, PostgreSQLParserIMMEDIATE, PostgreSQLParserIMMUTABLE, PostgreSQLParserIMPLICIT_P, PostgreSQLParserINCLUDING, PostgreSQLParserINCREMENT, PostgreSQLParserINDEX, PostgreSQLParserINDEXES, PostgreSQLParserINHERIT, PostgreSQLParserINHERITS, PostgreSQLParserINLINE_P, PostgreSQLParserINSENSITIVE, PostgreSQLParserINSERT, PostgreSQLParserINSTEAD, PostgreSQLParserINVOKER, PostgreSQLParserISOLATION, PostgreSQLParserKEY, PostgreSQLParserLABEL, PostgreSQLParserLANGUAGE, PostgreSQLParserLARGE_P, PostgreSQLParserLAST_P, PostgreSQLParserLEAKPROOF, PostgreSQLParserLEVEL, PostgreSQLParserLISTEN, PostgreSQLParserLOAD, PostgreSQLParserLOCAL, PostgreSQLParserLOCATION, PostgreSQLParserLOCK_P, PostgreSQLParserMAPPING, PostgreSQLParserMATCH, PostgreSQLParserMATERIALIZED, PostgreSQLParserMAXVALUE, PostgreSQLParserMINUTE_P, PostgreSQLParserMINVALUE, PostgreSQLParserMODE, PostgreSQLParserMONTH_P, PostgreSQLParserMOVE, PostgreSQLParserNAME_P, PostgreSQLParserNAMES, PostgreSQLParserNEXT, PostgreSQLParserNO, PostgreSQLParserNOTHING, PostgreSQLParserNOTIFY, PostgreSQLParserNOWAIT, PostgreSQLParserNULLS_P, PostgreSQLParserOBJECT_P, PostgreSQLParserOF, PostgreSQLParserOFF, PostgreSQLParserOIDS, PostgreSQLParserOPERATOR, PostgreSQLParserOPTION, PostgreSQLParserOPTIONS, PostgreSQLParserOWNED, PostgreSQLParserOWNER, PostgreSQLParserPARSER, PostgreSQLParserPARTIAL, PostgreSQLParserPARTITION, PostgreSQLParserPASSING, PostgreSQLParserPASSWORD, PostgreSQLParserPLANS, PostgreSQLParserPRECEDING, PostgreSQLParserPREPARE, PostgreSQLParserPREPARED, PostgreSQLParserPRESERVE, PostgreSQLParserPRIOR, PostgreSQLParserPRIVILEGES, PostgreSQLParserPROCEDURAL, PostgreSQLParserPROCEDURE, PostgreSQLParserPROGRAM, PostgreSQLParserQUOTE, PostgreSQLParserRANGE, PostgreSQLParserREAD, PostgreSQLParserREASSIGN, PostgreSQLParserRECHECK, PostgreSQLParserRECURSIVE, PostgreSQLParserREF, PostgreSQLParserREFRESH, PostgreSQLParserREINDEX, PostgreSQLParserRELATIVE_P, PostgreSQLParserRELEASE, PostgreSQLParserRENAME, PostgreSQLParserREPEATABLE, PostgreSQLParserREPLACE, PostgreSQLParserREPLICA, PostgreSQLParserRESET, PostgreSQLParserRESTART, PostgreSQLParserRESTRICT, PostgreSQLParserRETURNS, PostgreSQLParserREVOKE, PostgreSQLParserROLE, PostgreSQLParserROLLBACK, PostgreSQLParserROWS, PostgreSQLParserRULE, PostgreSQLParserSAVEPOINT, PostgreSQLParserSCHEMA, PostgreSQLParserSCROLL, PostgreSQLParserSEARCH, PostgreSQLParserSECOND_P, PostgreSQLParserSECURITY, PostgreSQLParserSEQUENCE, PostgreSQLParserSEQUENCES, PostgreSQLParserSERIALIZABLE, PostgreSQLParserSERVER, PostgreSQLParserSESSION, PostgreSQLParserSET, PostgreSQLParserSHARE, PostgreSQLParserSHOW, PostgreSQLParserSIMPLE, PostgreSQLParserSNAPSHOT, PostgreSQLParserSTABLE, PostgreSQLParserSTANDALONE_P, PostgreSQLParserSTART, PostgreSQLParserSTATEMENT, PostgreSQLParserSTATISTICS, PostgreSQLParserSTDIN, PostgreSQLParserSTDOUT, PostgreSQLParserSTORAGE, PostgreSQLParserSTRICT_P, PostgreSQLParserSTRIP_P, PostgreSQLParserSYSID, PostgreSQLParserSYSTEM_P, PostgreSQLParserTABLES, PostgreSQLParserTABLESPACE, PostgreSQLParserTEMP, PostgreSQLParserTEMPLATE, PostgreSQLParserTEMPORARY, PostgreSQLParserTEXT_P, PostgreSQLParserTRANSACTION, PostgreSQLParserTRIGGER, PostgreSQLParserTRUNCATE, PostgreSQLParserTRUSTED, PostgreSQLParserTYPE_P, PostgreSQLParserTYPES_P, PostgreSQLParserUNBOUNDED, PostgreSQLParserUNCOMMITTED, PostgreSQLParserUNENCRYPTED, PostgreSQLParserUNKNOWN, PostgreSQLParserUNLISTEN, PostgreSQLParserUNLOGGED, PostgreSQLParserUNTIL, PostgreSQLParserUPDATE, PostgreSQLParserVACUUM, PostgreSQLParserVALID, PostgreSQLParserVALIDATE, PostgreSQLParserVALIDATOR, PostgreSQLParserVARYING, PostgreSQLParserVERSION_P, PostgreSQLParserVIEW, PostgreSQLParserVOLATILE, PostgreSQLParserWHITESPACE_P, PostgreSQLParserWITHOUT, PostgreSQLParserWORK, PostgreSQLParserWRAPPER, PostgreSQLParserWRITE, PostgreSQLParserXML_P, PostgreSQLParserYEAR_P, PostgreSQLParserYES_P, PostgreSQLParserZONE, PostgreSQLParserBETWEEN, PostgreSQLParserBIGINT, PostgreSQLParserBIT, PostgreSQLParserBOOLEAN_P, PostgreSQLParserCHAR_P, PostgreSQLParserCHARACTER, PostgreSQLParserCOALESCE, PostgreSQLParserDEC, PostgreSQLParserDECIMAL_P, PostgreSQLParserEXISTS, PostgreSQLParserEXTRACT, PostgreSQLParserFLOAT_P, PostgreSQLParserGREATEST, PostgreSQLParserINOUT, PostgreSQLParserINT_P, PostgreSQLParserINTEGER, PostgreSQLParserINTERVAL, PostgreSQLParserLEAST, PostgreSQLParserNATIONAL, PostgreSQLParserNCHAR, PostgreSQLParserNONE, PostgreSQLParserNULLIF, PostgreSQLParserNUMERIC, PostgreSQLParserOVERLAY, PostgreSQLParserPOSITION, PostgreSQLParserPRECISION, PostgreSQLParserREAL, PostgreSQLParserROW, PostgreSQLParserSETOF, PostgreSQLParserSMALLINT, PostgreSQLParserSUBSTRING, PostgreSQLParserTIME, PostgreSQLParserTIMESTAMP, PostgreSQLParserTREAT, PostgreSQLParserTRIM, PostgreSQLParserVALUES, PostgreSQLParserVARCHAR, PostgreSQLParserXMLATTRIBUTES, PostgreSQLParserXMLCOMMENT, PostgreSQLParserXMLAGG, PostgreSQLParserXML_IS_WELL_FORMED, PostgreSQLParserXML_IS_WELL_FORMED_DOCUMENT, PostgreSQLParserXML_IS_WELL_FORMED_CONTENT, PostgreSQLParserXPATH, PostgreSQLParserXPATH_EXISTS, PostgreSQLParserXMLCONCAT, PostgreSQLParserXMLELEMENT, PostgreSQLParserXMLEXISTS, PostgreSQLParserXMLFOREST, PostgreSQLParserXMLPARSE, PostgreSQLParserXMLPI, PostgreSQLParserXMLROOT, PostgreSQLParserXMLSERIALIZE, PostgreSQLParserCALL, PostgreSQLParserCURRENT_P, PostgreSQLParserATTACH, PostgreSQLParserDETACH, PostgreSQLParserEXPRESSION, PostgreSQLParserGENERATED, PostgreSQLParserLOGGED, PostgreSQLParserSTORED, PostgreSQLParserINCLUDE, PostgreSQLParserROUTINE, PostgreSQLParserTRANSFORM, PostgreSQLParserIMPORT_P, PostgreSQLParserPOLICY, PostgreSQLParserMETHOD, PostgreSQLParserREFERENCING, PostgreSQLParserNEW, PostgreSQLParserOLD, PostgreSQLParserVALUE_P, PostgreSQLParserSUBSCRIPTION, PostgreSQLParserPUBLICATION, PostgreSQLParserOUT_P, PostgreSQLParserROUTINES, PostgreSQLParserSCHEMAS, PostgreSQLParserPROCEDURES, PostgreSQLParserINPUT_P, PostgreSQLParserSUPPORT, PostgreSQLParserPARALLEL, PostgreSQLParserSQL_P, PostgreSQLParserDEPENDS, PostgreSQLParserOVERRIDING, PostgreSQLParserCONFLICT, PostgreSQLParserSKIP_P, PostgreSQLParserLOCKED, PostgreSQLParserTIES, PostgreSQLParserROLLUP, PostgreSQLParserCUBE, PostgreSQLParserGROUPING, PostgreSQLParserSETS, PostgreSQLParserORDINALITY, PostgreSQLParserXMLTABLE, PostgreSQLParserCOLUMNS, PostgreSQLParserXMLNAMESPACES, PostgreSQLParserROWTYPE, PostgreSQLParserNORMALIZED, PostgreSQLParserWITHIN, PostgreSQLParserFILTER, PostgreSQLParserGROUPS, PostgreSQLParserOTHERS, PostgreSQLParserNFC, PostgreSQLParserNFD, PostgreSQLParserNFKC, PostgreSQLParserNFKD, PostgreSQLParserUESCAPE, PostgreSQLParserVIEWS, PostgreSQLParserNORMALIZE, PostgreSQLParserDUMP, PostgreSQLParserPRINT_STRICT_PARAMS, PostgreSQLParserVARIABLE_CONFLICT, PostgreSQLParserERROR, PostgreSQLParserUSE_VARIABLE, PostgreSQLParserUSE_COLUMN, PostgreSQLParserALIAS, PostgreSQLParserCONSTANT, PostgreSQLParserPERFORM, PostgreSQLParserGET, PostgreSQLParserDIAGNOSTICS, PostgreSQLParserSTACKED, PostgreSQLParserELSIF, PostgreSQLParserREVERSE, PostgreSQLParserSLICE, PostgreSQLParserEXIT, PostgreSQLParserRETURN, PostgreSQLParserQUERY, PostgreSQLParserRAISE, PostgreSQLParserSQLSTATE, PostgreSQLParserDEBUG, PostgreSQLParserLOG, PostgreSQLParserINFO, PostgreSQLParserNOTICE, PostgreSQLParserWARNING, PostgreSQLParserEXCEPTION, PostgreSQLParserASSERT, PostgreSQLParserOPEN, PostgreSQLParserABS, PostgreSQLParserCBRT, PostgreSQLParserCEIL, PostgreSQLParserCEILING, PostgreSQLParserDEGREES, PostgreSQLParserDIV, PostgreSQLParserEXP, PostgreSQLParserFACTORIAL, PostgreSQLParserFLOOR, PostgreSQLParserGCD, PostgreSQLParserLCM, PostgreSQLParserLN, PostgreSQLParserLOG10, PostgreSQLParserMIN_SCALE, PostgreSQLParserMOD, PostgreSQLParserPI, PostgreSQLParserPOWER, PostgreSQLParserRADIANS, PostgreSQLParserROUND, PostgreSQLParserSCALE, PostgreSQLParserSIGN, PostgreSQLParserSQRT, PostgreSQLParserTRIM_SCALE, PostgreSQLParserTRUNC, PostgreSQLParserWIDTH_BUCKET, PostgreSQLParserRANDOM, PostgreSQLParserSETSEED, PostgreSQLParserACOS, PostgreSQLParserACOSD, PostgreSQLParserASIN, PostgreSQLParserASIND, PostgreSQLParserATAN, PostgreSQLParserATAND, PostgreSQLParserATAN2, PostgreSQLParserATAN2D, PostgreSQLParserCOS, PostgreSQLParserCOSD, PostgreSQLParserCOT, PostgreSQLParserCOTD, PostgreSQLParserSIN, PostgreSQLParserSIND, PostgreSQLParserTAN, PostgreSQLParserTAND, PostgreSQLParserSINH, PostgreSQLParserCOSH, PostgreSQLParserTANH, PostgreSQLParserASINH, PostgreSQLParserACOSH, PostgreSQLParserATANH, PostgreSQLParserBIT_LENGTH, PostgreSQLParserCHAR_LENGTH, PostgreSQLParserCHARACTER_LENGTH, PostgreSQLParserLOWER, PostgreSQLParserOCTET_LENGTH, PostgreSQLParserUPPER, PostgreSQLParserASCII, PostgreSQLParserBTRIM, PostgreSQLParserCHR, PostgreSQLParserCONCAT, PostgreSQLParserCONCAT_WS, PostgreSQLParserFORMAT, PostgreSQLParserINITCAP, PostgreSQLParserLENGTH, PostgreSQLParserLPAD, PostgreSQLParserLTRIM, PostgreSQLParserMD5, PostgreSQLParserPARSE_IDENT, PostgreSQLParserPG_CLIENT_ENCODING, PostgreSQLParserQUOTE_IDENT, PostgreSQLParserQUOTE_LITERAL, PostgreSQLParserQUOTE_NULLABLE, PostgreSQLParserREGEXP_COUNT, PostgreSQLParserREGEXP_INSTR, PostgreSQLParserREGEXP_LIKE, PostgreSQLParserREGEXP_MATCH, PostgreSQLParserREGEXP_MATCHES, PostgreSQLParserREGEXP_REPLACE, PostgreSQLParserREGEXP_SPLIT_TO_ARRAY, PostgreSQLParserREGEXP_SPLIT_TO_TABLE, PostgreSQLParserREGEXP_SUBSTR, PostgreSQLParserREPEAT, PostgreSQLParserRPAD, PostgreSQLParserRTRIM, PostgreSQLParserSPLIT_PART, PostgreSQLParserSTARTS_WITH, PostgreSQLParserSTRING_TO_ARRAY, PostgreSQLParserSTRING_TO_TABLE, PostgreSQLParserSTRPOS, PostgreSQLParserSUBSTR, PostgreSQLParserTO_ASCII, PostgreSQLParserTO_HEX, PostgreSQLParserTRANSLATE, PostgreSQLParserUNISTR, PostgreSQLParserAGE, PostgreSQLParserCLOCK_TIMESTAMP, PostgreSQLParserDATE_BIN, PostgreSQLParserDATE_PART, PostgreSQLParserDATE_TRUNC, PostgreSQLParserISFINITE, PostgreSQLParserJUSTIFY_DAYS, PostgreSQLParserJUSTIFY_HOURS, PostgreSQLParserJUSTIFY_INTERVAL, PostgreSQLParserMAKE_DATE, PostgreSQLParserMAKE_INTERVAL, PostgreSQLParserMAKE_TIME, PostgreSQLParserMAKE_TIMESTAMP, PostgreSQLParserMAKE_TIMESTAMPTZ, PostgreSQLParserNOW, PostgreSQLParserSTATEMENT_TIMESTAMP, PostgreSQLParserTIMEOFDAY, PostgreSQLParserTRANSACTION_TIMESTAMP, PostgreSQLParserTO_TIMESTAMP, PostgreSQLParserTO_CHAR, PostgreSQLParserTO_DATE, PostgreSQLParserTO_NUMBER, PostgreSQLParserIdentifier, PostgreSQLParserQuotedIdentifier, PostgreSQLParserUnicodeQuotedIdentifier, PostgreSQLParserPLSQLVARIABLENAME, PostgreSQLParserPLSQLIDENTIFIER:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(10654)
			p.Any_identifier()
		}

	default:
		p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IOpt_exitcondContext is an interface to support dynamic dispatch.
type IOpt_exitcondContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	WHEN() antlr.TerminalNode
	Expr_until_semi() IExpr_until_semiContext

	// IsOpt_exitcondContext differentiates from other interfaces.
	IsOpt_exitcondContext()
}

type Opt_exitcondContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyOpt_exitcondContext() *Opt_exitcondContext {
	var p = new(Opt_exitcondContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opt_exitcond
	return p
}

func InitEmptyOpt_exitcondContext(p *Opt_exitcondContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opt_exitcond
}

func (*Opt_exitcondContext) IsOpt_exitcondContext() {}

func NewOpt_exitcondContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_exitcondContext {
	var p = new(Opt_exitcondContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_opt_exitcond

	return p
}

func (s *Opt_exitcondContext) GetParser() antlr.Parser { return s.parser }

func (s *Opt_exitcondContext) WHEN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserWHEN, 0)
}

func (s *Opt_exitcondContext) Expr_until_semi() IExpr_until_semiContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IExpr_until_semiContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IExpr_until_semiContext)
}

func (s *Opt_exitcondContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Opt_exitcondContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Opt_exitcondContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterOpt_exitcond(s)
	}
}

func (s *Opt_exitcondContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitOpt_exitcond(s)
	}
}

func (s *Opt_exitcondContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitOpt_exitcond(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Opt_exitcond() (localctx IOpt_exitcondContext) {
	localctx = NewOpt_exitcondContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1604, PostgreSQLParserRULE_opt_exitcond)
	p.SetState(10660)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetTokenStream().LA(1) {
	case PostgreSQLParserWHEN:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(10657)
			p.Match(PostgreSQLParserWHEN)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(10658)
			p.Expr_until_semi()
		}

	case PostgreSQLParserSEMI:
		p.EnterOuterAlt(localctx, 2)

	default:
		p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IAny_identifierContext is an interface to support dynamic dispatch.
type IAny_identifierContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Colid() IColidContext
	Plsql_unreserved_keyword() IPlsql_unreserved_keywordContext

	// IsAny_identifierContext differentiates from other interfaces.
	IsAny_identifierContext()
}

type Any_identifierContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyAny_identifierContext() *Any_identifierContext {
	var p = new(Any_identifierContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_any_identifier
	return p
}

func InitEmptyAny_identifierContext(p *Any_identifierContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_any_identifier
}

func (*Any_identifierContext) IsAny_identifierContext() {}

func NewAny_identifierContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Any_identifierContext {
	var p = new(Any_identifierContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_any_identifier

	return p
}

func (s *Any_identifierContext) GetParser() antlr.Parser { return s.parser }

func (s *Any_identifierContext) Colid() IColidContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IColidContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IColidContext)
}

func (s *Any_identifierContext) Plsql_unreserved_keyword() IPlsql_unreserved_keywordContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IPlsql_unreserved_keywordContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IPlsql_unreserved_keywordContext)
}

func (s *Any_identifierContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Any_identifierContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Any_identifierContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterAny_identifier(s)
	}
}

func (s *Any_identifierContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitAny_identifier(s)
	}
}

func (s *Any_identifierContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitAny_identifier(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Any_identifier() (localctx IAny_identifierContext) {
	localctx = NewAny_identifierContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1606, PostgreSQLParserRULE_any_identifier)
	p.SetState(10664)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 742, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(10662)
			p.Colid()
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(10663)
			p.Plsql_unreserved_keyword()
		}

	case antlr.ATNInvalidAltNumber:
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IPlsql_unreserved_keywordContext is an interface to support dynamic dispatch.
type IPlsql_unreserved_keywordContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	ABSOLUTE_P() antlr.TerminalNode
	ALIAS() antlr.TerminalNode
	AND() antlr.TerminalNode
	ARRAY() antlr.TerminalNode
	ASSERT() antlr.TerminalNode
	BACKWARD() antlr.TerminalNode
	CALL() antlr.TerminalNode
	CHAIN() antlr.TerminalNode
	CLOSE() antlr.TerminalNode
	COLLATE() antlr.TerminalNode
	COLUMN() antlr.TerminalNode
	COMMIT() antlr.TerminalNode
	CONSTANT() antlr.TerminalNode
	CONSTRAINT() antlr.TerminalNode
	CONTINUE_P() antlr.TerminalNode
	CURRENT_P() antlr.TerminalNode
	CURSOR() antlr.TerminalNode
	DEBUG() antlr.TerminalNode
	DEFAULT() antlr.TerminalNode
	DIAGNOSTICS() antlr.TerminalNode
	DO() antlr.TerminalNode
	DUMP() antlr.TerminalNode
	ELSIF() antlr.TerminalNode
	ERROR() antlr.TerminalNode
	EXCEPTION() antlr.TerminalNode
	EXIT() antlr.TerminalNode
	FETCH() antlr.TerminalNode
	FIRST_P() antlr.TerminalNode
	FORWARD() antlr.TerminalNode
	GET() antlr.TerminalNode
	INFO() antlr.TerminalNode
	INSERT() antlr.TerminalNode
	IS() antlr.TerminalNode
	LAST_P() antlr.TerminalNode
	MOVE() antlr.TerminalNode
	NEXT() antlr.TerminalNode
	NO() antlr.TerminalNode
	NOTICE() antlr.TerminalNode
	OPEN() antlr.TerminalNode
	OPTION() antlr.TerminalNode
	PERFORM() antlr.TerminalNode
	PRINT_STRICT_PARAMS() antlr.TerminalNode
	PRIOR() antlr.TerminalNode
	QUERY() antlr.TerminalNode
	RAISE() antlr.TerminalNode
	RELATIVE_P() antlr.TerminalNode
	RESET() antlr.TerminalNode
	RETURN() antlr.TerminalNode
	ROLLBACK() antlr.TerminalNode
	ROWTYPE() antlr.TerminalNode
	SCHEMA() antlr.TerminalNode
	SCROLL() antlr.TerminalNode
	SET() antlr.TerminalNode
	SLICE() antlr.TerminalNode
	SQLSTATE() antlr.TerminalNode
	STACKED() antlr.TerminalNode
	TABLE() antlr.TerminalNode
	TYPE_P() antlr.TerminalNode
	USE_COLUMN() antlr.TerminalNode
	USE_VARIABLE() antlr.TerminalNode
	VARIABLE_CONFLICT() antlr.TerminalNode
	WARNING() antlr.TerminalNode
	OUTER_P() antlr.TerminalNode

	// IsPlsql_unreserved_keywordContext differentiates from other interfaces.
	IsPlsql_unreserved_keywordContext()
}

type Plsql_unreserved_keywordContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyPlsql_unreserved_keywordContext() *Plsql_unreserved_keywordContext {
	var p = new(Plsql_unreserved_keywordContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_plsql_unreserved_keyword
	return p
}

func InitEmptyPlsql_unreserved_keywordContext(p *Plsql_unreserved_keywordContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_plsql_unreserved_keyword
}

func (*Plsql_unreserved_keywordContext) IsPlsql_unreserved_keywordContext() {}

func NewPlsql_unreserved_keywordContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Plsql_unreserved_keywordContext {
	var p = new(Plsql_unreserved_keywordContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_plsql_unreserved_keyword

	return p
}

func (s *Plsql_unreserved_keywordContext) GetParser() antlr.Parser { return s.parser }

func (s *Plsql_unreserved_keywordContext) ABSOLUTE_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserABSOLUTE_P, 0)
}

func (s *Plsql_unreserved_keywordContext) ALIAS() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserALIAS, 0)
}

func (s *Plsql_unreserved_keywordContext) AND() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserAND, 0)
}

func (s *Plsql_unreserved_keywordContext) ARRAY() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserARRAY, 0)
}

func (s *Plsql_unreserved_keywordContext) ASSERT() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserASSERT, 0)
}

func (s *Plsql_unreserved_keywordContext) BACKWARD() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserBACKWARD, 0)
}

func (s *Plsql_unreserved_keywordContext) CALL() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCALL, 0)
}

func (s *Plsql_unreserved_keywordContext) CHAIN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCHAIN, 0)
}

func (s *Plsql_unreserved_keywordContext) CLOSE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCLOSE, 0)
}

func (s *Plsql_unreserved_keywordContext) COLLATE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCOLLATE, 0)
}

func (s *Plsql_unreserved_keywordContext) COLUMN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCOLUMN, 0)
}

func (s *Plsql_unreserved_keywordContext) COMMIT() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCOMMIT, 0)
}

func (s *Plsql_unreserved_keywordContext) CONSTANT() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCONSTANT, 0)
}

func (s *Plsql_unreserved_keywordContext) CONSTRAINT() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCONSTRAINT, 0)
}

func (s *Plsql_unreserved_keywordContext) CONTINUE_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCONTINUE_P, 0)
}

func (s *Plsql_unreserved_keywordContext) CURRENT_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCURRENT_P, 0)
}

func (s *Plsql_unreserved_keywordContext) CURSOR() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserCURSOR, 0)
}

func (s *Plsql_unreserved_keywordContext) DEBUG() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserDEBUG, 0)
}

func (s *Plsql_unreserved_keywordContext) DEFAULT() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserDEFAULT, 0)
}

func (s *Plsql_unreserved_keywordContext) DIAGNOSTICS() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserDIAGNOSTICS, 0)
}

func (s *Plsql_unreserved_keywordContext) DO() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserDO, 0)
}

func (s *Plsql_unreserved_keywordContext) DUMP() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserDUMP, 0)
}

func (s *Plsql_unreserved_keywordContext) ELSIF() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserELSIF, 0)
}

func (s *Plsql_unreserved_keywordContext) ERROR() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserERROR, 0)
}

func (s *Plsql_unreserved_keywordContext) EXCEPTION() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserEXCEPTION, 0)
}

func (s *Plsql_unreserved_keywordContext) EXIT() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserEXIT, 0)
}

func (s *Plsql_unreserved_keywordContext) FETCH() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserFETCH, 0)
}

func (s *Plsql_unreserved_keywordContext) FIRST_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserFIRST_P, 0)
}

func (s *Plsql_unreserved_keywordContext) FORWARD() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserFORWARD, 0)
}

func (s *Plsql_unreserved_keywordContext) GET() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserGET, 0)
}

func (s *Plsql_unreserved_keywordContext) INFO() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserINFO, 0)
}

func (s *Plsql_unreserved_keywordContext) INSERT() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserINSERT, 0)
}

func (s *Plsql_unreserved_keywordContext) IS() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserIS, 0)
}

func (s *Plsql_unreserved_keywordContext) LAST_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserLAST_P, 0)
}

func (s *Plsql_unreserved_keywordContext) MOVE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserMOVE, 0)
}

func (s *Plsql_unreserved_keywordContext) NEXT() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserNEXT, 0)
}

func (s *Plsql_unreserved_keywordContext) NO() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserNO, 0)
}

func (s *Plsql_unreserved_keywordContext) NOTICE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserNOTICE, 0)
}

func (s *Plsql_unreserved_keywordContext) OPEN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserOPEN, 0)
}

func (s *Plsql_unreserved_keywordContext) OPTION() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserOPTION, 0)
}

func (s *Plsql_unreserved_keywordContext) PERFORM() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserPERFORM, 0)
}

func (s *Plsql_unreserved_keywordContext) PRINT_STRICT_PARAMS() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserPRINT_STRICT_PARAMS, 0)
}

func (s *Plsql_unreserved_keywordContext) PRIOR() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserPRIOR, 0)
}

func (s *Plsql_unreserved_keywordContext) QUERY() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserQUERY, 0)
}

func (s *Plsql_unreserved_keywordContext) RAISE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserRAISE, 0)
}

func (s *Plsql_unreserved_keywordContext) RELATIVE_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserRELATIVE_P, 0)
}

func (s *Plsql_unreserved_keywordContext) RESET() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserRESET, 0)
}

func (s *Plsql_unreserved_keywordContext) RETURN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserRETURN, 0)
}

func (s *Plsql_unreserved_keywordContext) ROLLBACK() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserROLLBACK, 0)
}

func (s *Plsql_unreserved_keywordContext) ROWTYPE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserROWTYPE, 0)
}

func (s *Plsql_unreserved_keywordContext) SCHEMA() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserSCHEMA, 0)
}

func (s *Plsql_unreserved_keywordContext) SCROLL() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserSCROLL, 0)
}

func (s *Plsql_unreserved_keywordContext) SET() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserSET, 0)
}

func (s *Plsql_unreserved_keywordContext) SLICE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserSLICE, 0)
}

func (s *Plsql_unreserved_keywordContext) SQLSTATE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserSQLSTATE, 0)
}

func (s *Plsql_unreserved_keywordContext) STACKED() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserSTACKED, 0)
}

func (s *Plsql_unreserved_keywordContext) TABLE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserTABLE, 0)
}

func (s *Plsql_unreserved_keywordContext) TYPE_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserTYPE_P, 0)
}

func (s *Plsql_unreserved_keywordContext) USE_COLUMN() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserUSE_COLUMN, 0)
}

func (s *Plsql_unreserved_keywordContext) USE_VARIABLE() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserUSE_VARIABLE, 0)
}

func (s *Plsql_unreserved_keywordContext) VARIABLE_CONFLICT() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserVARIABLE_CONFLICT, 0)
}

func (s *Plsql_unreserved_keywordContext) WARNING() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserWARNING, 0)
}

func (s *Plsql_unreserved_keywordContext) OUTER_P() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserOUTER_P, 0)
}

func (s *Plsql_unreserved_keywordContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Plsql_unreserved_keywordContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Plsql_unreserved_keywordContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterPlsql_unreserved_keyword(s)
	}
}

func (s *Plsql_unreserved_keywordContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitPlsql_unreserved_keyword(s)
	}
}

func (s *Plsql_unreserved_keywordContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitPlsql_unreserved_keyword(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Plsql_unreserved_keyword() (localctx IPlsql_unreserved_keywordContext) {
	localctx = NewPlsql_unreserved_keywordContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1608, PostgreSQLParserRULE_plsql_unreserved_keyword)
	var _la int

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(10666)
		_la = p.GetTokenStream().LA(1)

		if !(((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&2459027012145119232) != 0) || ((int64((_la-92)) & ^0x3f) == 0 && ((int64(1)<<(_la-92))&2310346885883232257) != 0) || ((int64((_la-157)) & ^0x3f) == 0 && ((int64(1)<<(_la-157))&10133099161617425) != 0) || ((int64((_la-232)) & ^0x3f) == 0 && ((int64(1)<<(_la-232))&18015499698831617) != 0) || ((int64((_la-300)) & ^0x3f) == 0 && ((int64(1)<<(_la-300))&9007199322050625) != 0) || ((int64((_la-433)) & ^0x3f) == 0 && ((int64(1)<<(_la-433))&-144097595889811453) != 0) || ((int64((_la-497)) & ^0x3f) == 0 && ((int64(1)<<(_la-497))&12516927) != 0)) {
			p.GetErrorHandler().RecoverInline(p)
		} else {
			p.GetErrorHandler().ReportMatch(p)
			p.Consume()
		}
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// ISql_expressionContext is an interface to support dynamic dispatch.
type ISql_expressionContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Opt_target_list() IOpt_target_listContext
	Into_clause() IInto_clauseContext
	From_clause() IFrom_clauseContext
	Where_clause() IWhere_clauseContext
	Group_clause() IGroup_clauseContext
	Having_clause() IHaving_clauseContext
	Window_clause() IWindow_clauseContext

	// IsSql_expressionContext differentiates from other interfaces.
	IsSql_expressionContext()
}

type Sql_expressionContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptySql_expressionContext() *Sql_expressionContext {
	var p = new(Sql_expressionContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_sql_expression
	return p
}

func InitEmptySql_expressionContext(p *Sql_expressionContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_sql_expression
}

func (*Sql_expressionContext) IsSql_expressionContext() {}

func NewSql_expressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Sql_expressionContext {
	var p = new(Sql_expressionContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_sql_expression

	return p
}

func (s *Sql_expressionContext) GetParser() antlr.Parser { return s.parser }

func (s *Sql_expressionContext) Opt_target_list() IOpt_target_listContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOpt_target_listContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOpt_target_listContext)
}

func (s *Sql_expressionContext) Into_clause() IInto_clauseContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IInto_clauseContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IInto_clauseContext)
}

func (s *Sql_expressionContext) From_clause() IFrom_clauseContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IFrom_clauseContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IFrom_clauseContext)
}

func (s *Sql_expressionContext) Where_clause() IWhere_clauseContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IWhere_clauseContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IWhere_clauseContext)
}

func (s *Sql_expressionContext) Group_clause() IGroup_clauseContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IGroup_clauseContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IGroup_clauseContext)
}

func (s *Sql_expressionContext) Having_clause() IHaving_clauseContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IHaving_clauseContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IHaving_clauseContext)
}

func (s *Sql_expressionContext) Window_clause() IWindow_clauseContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IWindow_clauseContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IWindow_clauseContext)
}

func (s *Sql_expressionContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Sql_expressionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Sql_expressionContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterSql_expression(s)
	}
}

func (s *Sql_expressionContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitSql_expression(s)
	}
}

func (s *Sql_expressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitSql_expression(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Sql_expression() (localctx ISql_expressionContext) {
	localctx = NewSql_expressionContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1610, PostgreSQLParserRULE_sql_expression)
	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(10668)
		p.Opt_target_list()
	}
	{
		p.SetState(10669)
		p.Into_clause()
	}
	{
		p.SetState(10670)
		p.From_clause()
	}
	{
		p.SetState(10671)
		p.Where_clause()
	}
	{
		p.SetState(10672)
		p.Group_clause()
	}
	{
		p.SetState(10673)
		p.Having_clause()
	}
	{
		p.SetState(10674)
		p.Window_clause()
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IExpr_until_thenContext is an interface to support dynamic dispatch.
type IExpr_until_thenContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Sql_expression() ISql_expressionContext

	// IsExpr_until_thenContext differentiates from other interfaces.
	IsExpr_until_thenContext()
}

type Expr_until_thenContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyExpr_until_thenContext() *Expr_until_thenContext {
	var p = new(Expr_until_thenContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_expr_until_then
	return p
}

func InitEmptyExpr_until_thenContext(p *Expr_until_thenContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_expr_until_then
}

func (*Expr_until_thenContext) IsExpr_until_thenContext() {}

func NewExpr_until_thenContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Expr_until_thenContext {
	var p = new(Expr_until_thenContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_expr_until_then

	return p
}

func (s *Expr_until_thenContext) GetParser() antlr.Parser { return s.parser }

func (s *Expr_until_thenContext) Sql_expression() ISql_expressionContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ISql_expressionContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ISql_expressionContext)
}

func (s *Expr_until_thenContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Expr_until_thenContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Expr_until_thenContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterExpr_until_then(s)
	}
}

func (s *Expr_until_thenContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitExpr_until_then(s)
	}
}

func (s *Expr_until_thenContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitExpr_until_then(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Expr_until_then() (localctx IExpr_until_thenContext) {
	localctx = NewExpr_until_thenContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1612, PostgreSQLParserRULE_expr_until_then)
	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(10676)
		p.Sql_expression()
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IExpr_until_semiContext is an interface to support dynamic dispatch.
type IExpr_until_semiContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Sql_expression() ISql_expressionContext

	// IsExpr_until_semiContext differentiates from other interfaces.
	IsExpr_until_semiContext()
}

type Expr_until_semiContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyExpr_until_semiContext() *Expr_until_semiContext {
	var p = new(Expr_until_semiContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_expr_until_semi
	return p
}

func InitEmptyExpr_until_semiContext(p *Expr_until_semiContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_expr_until_semi
}

func (*Expr_until_semiContext) IsExpr_until_semiContext() {}

func NewExpr_until_semiContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Expr_until_semiContext {
	var p = new(Expr_until_semiContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_expr_until_semi

	return p
}

func (s *Expr_until_semiContext) GetParser() antlr.Parser { return s.parser }

func (s *Expr_until_semiContext) Sql_expression() ISql_expressionContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(ISql_expressionContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(ISql_expressionContext)
}

func (s *Expr_until_semiContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Expr_until_semiContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Expr_until_semiContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterExpr_until_semi(s)
	}
}

func (s *Expr_until_semiContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitExpr_until_semi(s)
	}
}

func (s *Expr_until_semiContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitExpr_until_semi(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Expr_until_semi() (localctx IExpr_until_semiContext) {
	localctx = NewExpr_until_semiContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1614, PostgreSQLParserRULE_expr_until_semi)
	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(10678)
		p.Sql_expression()
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IExpr_until_rightbracketContext is an interface to support dynamic dispatch.
type IExpr_until_rightbracketContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	A_expr() IA_exprContext

	// IsExpr_until_rightbracketContext differentiates from other interfaces.
	IsExpr_until_rightbracketContext()
}

type Expr_until_rightbracketContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyExpr_until_rightbracketContext() *Expr_until_rightbracketContext {
	var p = new(Expr_until_rightbracketContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_expr_until_rightbracket
	return p
}

func InitEmptyExpr_until_rightbracketContext(p *Expr_until_rightbracketContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_expr_until_rightbracket
}

func (*Expr_until_rightbracketContext) IsExpr_until_rightbracketContext() {}

func NewExpr_until_rightbracketContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Expr_until_rightbracketContext {
	var p = new(Expr_until_rightbracketContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_expr_until_rightbracket

	return p
}

func (s *Expr_until_rightbracketContext) GetParser() antlr.Parser { return s.parser }

func (s *Expr_until_rightbracketContext) A_expr() IA_exprContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IA_exprContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IA_exprContext)
}

func (s *Expr_until_rightbracketContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Expr_until_rightbracketContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Expr_until_rightbracketContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterExpr_until_rightbracket(s)
	}
}

func (s *Expr_until_rightbracketContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitExpr_until_rightbracket(s)
	}
}

func (s *Expr_until_rightbracketContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitExpr_until_rightbracket(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Expr_until_rightbracket() (localctx IExpr_until_rightbracketContext) {
	localctx = NewExpr_until_rightbracketContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1616, PostgreSQLParserRULE_expr_until_rightbracket)
	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(10680)
		p.A_expr()
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IExpr_until_loopContext is an interface to support dynamic dispatch.
type IExpr_until_loopContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	A_expr() IA_exprContext

	// IsExpr_until_loopContext differentiates from other interfaces.
	IsExpr_until_loopContext()
}

type Expr_until_loopContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyExpr_until_loopContext() *Expr_until_loopContext {
	var p = new(Expr_until_loopContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_expr_until_loop
	return p
}

func InitEmptyExpr_until_loopContext(p *Expr_until_loopContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_expr_until_loop
}

func (*Expr_until_loopContext) IsExpr_until_loopContext() {}

func NewExpr_until_loopContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Expr_until_loopContext {
	var p = new(Expr_until_loopContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_expr_until_loop

	return p
}

func (s *Expr_until_loopContext) GetParser() antlr.Parser { return s.parser }

func (s *Expr_until_loopContext) A_expr() IA_exprContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IA_exprContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IA_exprContext)
}

func (s *Expr_until_loopContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Expr_until_loopContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Expr_until_loopContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterExpr_until_loop(s)
	}
}

func (s *Expr_until_loopContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitExpr_until_loop(s)
	}
}

func (s *Expr_until_loopContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitExpr_until_loop(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Expr_until_loop() (localctx IExpr_until_loopContext) {
	localctx = NewExpr_until_loopContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1618, PostgreSQLParserRULE_expr_until_loop)
	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(10682)
		p.A_expr()
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IMake_execsql_stmtContext is an interface to support dynamic dispatch.
type IMake_execsql_stmtContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Stmt() IStmtContext
	Opt_returning_clause_into() IOpt_returning_clause_intoContext

	// IsMake_execsql_stmtContext differentiates from other interfaces.
	IsMake_execsql_stmtContext()
}

type Make_execsql_stmtContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyMake_execsql_stmtContext() *Make_execsql_stmtContext {
	var p = new(Make_execsql_stmtContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_make_execsql_stmt
	return p
}

func InitEmptyMake_execsql_stmtContext(p *Make_execsql_stmtContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_make_execsql_stmt
}

func (*Make_execsql_stmtContext) IsMake_execsql_stmtContext() {}

func NewMake_execsql_stmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Make_execsql_stmtContext {
	var p = new(Make_execsql_stmtContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_make_execsql_stmt

	return p
}

func (s *Make_execsql_stmtContext) GetParser() antlr.Parser { return s.parser }

func (s *Make_execsql_stmtContext) Stmt() IStmtContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IStmtContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IStmtContext)
}

func (s *Make_execsql_stmtContext) Opt_returning_clause_into() IOpt_returning_clause_intoContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOpt_returning_clause_intoContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOpt_returning_clause_intoContext)
}

func (s *Make_execsql_stmtContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Make_execsql_stmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Make_execsql_stmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterMake_execsql_stmt(s)
	}
}

func (s *Make_execsql_stmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitMake_execsql_stmt(s)
	}
}

func (s *Make_execsql_stmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitMake_execsql_stmt(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Make_execsql_stmt() (localctx IMake_execsql_stmtContext) {
	localctx = NewMake_execsql_stmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1620, PostgreSQLParserRULE_make_execsql_stmt)
	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(10684)
		p.Stmt()
	}
	{
		p.SetState(10685)
		p.Opt_returning_clause_into()
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

// IOpt_returning_clause_intoContext is an interface to support dynamic dispatch.
type IOpt_returning_clause_intoContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	INTO() antlr.TerminalNode
	Opt_strict() IOpt_strictContext
	Into_target() IInto_targetContext

	// IsOpt_returning_clause_intoContext differentiates from other interfaces.
	IsOpt_returning_clause_intoContext()
}

type Opt_returning_clause_intoContext struct {
	antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyOpt_returning_clause_intoContext() *Opt_returning_clause_intoContext {
	var p = new(Opt_returning_clause_intoContext)
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opt_returning_clause_into
	return p
}

func InitEmptyOpt_returning_clause_intoContext(p *Opt_returning_clause_intoContext) {
	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
	p.RuleIndex = PostgreSQLParserRULE_opt_returning_clause_into
}

func (*Opt_returning_clause_intoContext) IsOpt_returning_clause_intoContext() {}

func NewOpt_returning_clause_intoContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_returning_clause_intoContext {
	var p = new(Opt_returning_clause_intoContext)

	antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

	p.parser = parser
	p.RuleIndex = PostgreSQLParserRULE_opt_returning_clause_into

	return p
}

func (s *Opt_returning_clause_intoContext) GetParser() antlr.Parser { return s.parser }

func (s *Opt_returning_clause_intoContext) INTO() antlr.TerminalNode {
	return s.GetToken(PostgreSQLParserINTO, 0)
}

func (s *Opt_returning_clause_intoContext) Opt_strict() IOpt_strictContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IOpt_strictContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IOpt_strictContext)
}

func (s *Opt_returning_clause_intoContext) Into_target() IInto_targetContext {
	var t antlr.RuleContext
	for _, ctx := range s.GetChildren() {
		if _, ok := ctx.(IInto_targetContext); ok {
			t = ctx.(antlr.RuleContext)
			break
		}
	}

	if t == nil {
		return nil
	}

	return t.(IInto_targetContext)
}

func (s *Opt_returning_clause_intoContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Opt_returning_clause_intoContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Opt_returning_clause_intoContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.EnterOpt_returning_clause_into(s)
	}
}

func (s *Opt_returning_clause_intoContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(PostgreSQLParserListener); ok {
		listenerT.ExitOpt_returning_clause_into(s)
	}
}

func (s *Opt_returning_clause_intoContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
	switch t := visitor.(type) {
	case PostgreSQLParserVisitor:
		return t.VisitOpt_returning_clause_into(s)

	default:
		return t.VisitChildren(s)
	}
}

func (p *PostgreSQLParser) Opt_returning_clause_into() (localctx IOpt_returning_clause_intoContext) {
	localctx = NewOpt_returning_clause_intoContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 1622, PostgreSQLParserRULE_opt_returning_clause_into)
	p.SetState(10692)
	p.GetErrorHandler().Sync(p)
	if p.HasError() {
		goto errorExit
	}

	switch p.GetTokenStream().LA(1) {
	case PostgreSQLParserINTO:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(10687)
			p.Match(PostgreSQLParserINTO)
			if p.HasError() {
				// Recognition error - abort rule
				goto errorExit
			}
		}
		{
			p.SetState(10688)
			p.Opt_strict()
		}
		{
			p.SetState(10689)
			p.Into_target()
		}

	case PostgreSQLParserSEMI:
		p.EnterOuterAlt(localctx, 2)

	default:
		p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		goto errorExit
	}

errorExit:
	if p.HasError() {
		v := p.GetError()
		localctx.SetException(v)
		p.GetErrorHandler().ReportError(p, v)
		p.GetErrorHandler().Recover(p, v)
		p.SetError(nil)
	}
	p.ExitRule()
	return localctx
	goto errorExit // Trick to prevent compiler error if the label is not used
}

func (p *PostgreSQLParser) Sempred(localctx antlr.RuleContext, ruleIndex, predIndex int) bool {
	switch ruleIndex {
	case 602:
		var t *B_exprContext = nil
		if localctx != nil {
			t = localctx.(*B_exprContext)
		}
		return p.B_expr_Sempred(t, predIndex)

	default:
		panic("No predicate with index: " + fmt.Sprint(ruleIndex))
	}
}

func (p *PostgreSQLParser) B_expr_Sempred(localctx antlr.RuleContext, predIndex int) bool {
	switch predIndex {
	case 0:
		return p.Precpred(p.GetParserRuleContext(), 8)

	case 1:
		return p.Precpred(p.GetParserRuleContext(), 7)

	case 2:
		return p.Precpred(p.GetParserRuleContext(), 6)

	case 3:
		return p.Precpred(p.GetParserRuleContext(), 5)

	case 4:
		return p.Precpred(p.GetParserRuleContext(), 4)

	case 5:
		return p.Precpred(p.GetParserRuleContext(), 10)

	case 6:
		return p.Precpred(p.GetParserRuleContext(), 2)

	case 7:
		return p.Precpred(p.GetParserRuleContext(), 1)

	default:
		panic("No predicate with index: " + fmt.Sprint(predIndex))
	}
}
